@mathquis/modelx-resolvables-test v2.0.0

ModelX Resolvables

Resolve ModelX model recursively

Installation

This package requires @mathquis/modelx installed as a peer dependency.

npm install -D @mathquis/modelx-resolvables

Usage

import { AbstractResolvableModel, AbstractResolvableCollection, resolvable } from '@mathquis/modelx-resolvables';
import { ModelClass } from '@mathquis/modelx/lib/types/collection';
import { Model } from '@mathquis/modelx';

class ResolvableCollection extends AbstractResolvableCollection {
	public listById<T extends AbstractResolvableModel>(identifiers: Identifier[]): Promise<this> {
		// Implement how to list model by ids
	}
}

class UnresolvedModel extends AbstractResolvableModel {}

class ParentModel extends AbstractResolvableModel {}

class ResolvableModel extends AbstractResolvableModel {
	@resolvable({
		// Model attribute used as resolvable attributes
		attributeName: 'parent',
		// Automatically resolves (no need to have a resolution schema)
		auto: true,
		// Store the resolvable in cache for later resolutions
		cache: true,
		// Store the resolvable in a collection specific cache
		// If false (default) then store the resolvable in a global cache
		local: true,
		// Model to instanciate when the resolvable is not resolved
		unresolved: UnresolvedModel,
		// Model to use if base property value is already unresolved model
		model: ParentModel,
		// Only allow specific models (model and unresolved will be automatically allowed)
		allow: [ParentAltModel]
	})
	public parent = new ParentModel();

	// How to interpret resolvable attribute
	protected getModelFromAttribute<T extends AbstractResolvableModel>(propName: string, attribute: any, modelClass: ModelClass<T>): AbstractResolvableModel {
		return new modelClass(attribute);
	}

	// How  attribute is interpreted from resolvable
	protected getAttributeFromModel(model: Model): any {
		return model.attributes;
	}

	public getResolvableCollection(modelClass: ModelClass<AbstractResolvableModel>, options: IResolverCollectionOptions): AbstractResolvableCollection<AbstractResolvableModel> {
		// Implement how to return a resolvable collection instance for this model
	}
}

Method 1

Using a resolver instance.

const schema = [
	{
		name: 'parent',
		options: {
			// Automatically resolves (no need to have a resolution schema)
			auto: true,
			// Store the resolvable in cache for later resolutions
			cache: true,
			// Store the resolvable in a collection specific cache
			// If false (default) then store the resolvable in a global cache
			local: true,
			// Model to instanciate when the resolvable is not resolved
			unresolved: UnresolvedModel,
			// Model to use if base property value is already unresolved model
			model: ParentModel
		},
		parents: []
	}
];

const resolver = new Resolver(schema, {
	// The list method will wait for the resolution to complete before resolving the promise
	waitForResolution: false,
	// The list method will not resolve the models
	skipResolution: false,
	// The list method will fail if one of the resolutions fails
	failOnError: false,
	// Dumps the resolution logs to the console
	log: true
});

const collection = new ResolvableCollection(ResolvableModel, [], {
	// Resolver
	resolver
});

await collection.list();

const model = new ResolvableModel({}, {
	// Resolver
	resolver
});

await model.setId(id).fetch();
await model.save();

Method 2

Using options.

const collection = new ResolvableCollection(ResolvableModel, [], {
	// Resolution schema [{name, parents: [], options: {}}, ...]
	schema,
	// The list method will wait for the resolution to complete before resolving the promise
	waitForResolution: false,
	// The list method will not resolve the models
	skipResolution: false,
	// The list method will fail if one of the resolutions fails
	failOnError: false,
	// Dumps the resolution logs to the console
	log: true
});

await collection.list();

const model = new ResolvableModel({}, {
	// Resolution schema [{name, parents: [], options: {}}, ...]
	schema,
	// The list method will wait for the resolution to complete before resolving the promise
	waitForResolution: false,
	// The list method will not resolve the models
	skipResolution: false,
	// The list method will fail if one of the resolutions fails
	failOnError: false,
	// Dumps the resolution logs to the console
	log: true
});

await model.setId(id).fetch();
await model.save();