@vsaas/loopback-datasource-juggler 10.0.0

package/dist/lib/mixins.js

@@ -0,0 +1,58 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_lib_model = require("./model.js");
+//#region src/lib/mixins.ts
+var require_mixins = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const debug = require("debug")("loopback:mixin");
+	const assert = require("assert");
+	const DefaultModelBaseClass = require_lib_model;
+	function isModelClass(cls) {
+		if (!cls) return false;
+		return cls.prototype instanceof DefaultModelBaseClass;
+	}
+	module.exports = MixinProvider;
+	function MixinProvider(modelBuilder) {
+		this.modelBuilder = modelBuilder;
+		this.mixins = {};
+	}
+	/**
+	* Apply named mixin to the model class
+	* @param {Model} modelClass
+	* @param {String} name
+	* @param {Object} options
+	*/
+	MixinProvider.prototype.applyMixin = function applyMixin(modelClass, name, options) {
+		const fn = this.mixins[name];
+		if (typeof fn === "function") if (modelClass.dataSource) fn(modelClass, options || {});
+		else modelClass.once("dataSourceAttached", function() {
+			fn(modelClass, options || {});
+		});
+		else {
+			const model = this.modelBuilder.getModel(name);
+			if (model) {
+				debug("Mixin is resolved to a model: %s", name);
+				modelClass.mixin(model, options);
+			} else {
+				const errMsg = "Model \"" + modelClass.modelName + "\" uses unknown mixin: " + name;
+				debug(errMsg);
+				throw new Error(errMsg);
+			}
+		}
+	};
+	/**
+	* Define a mixin with name
+	* @param {String} name Name of the mixin
+	* @param {*) mixin The mixin function or a model
+	*/
+	MixinProvider.prototype.define = function defineMixin(name, mixin) {
+		assert(typeof mixin === "function", "The mixin must be a function or model class");
+		if (this.mixins[name]) debug("Duplicate mixin: %s", name);
+		else debug("Defining mixin: %s", name);
+		if (isModelClass(mixin)) this.mixins[name] = function(Model, options) {
+			Model.mixin(mixin, options);
+		};
+		else if (typeof mixin === "function") this.mixins[name] = mixin;
+	};
+}));
+//#endregion
+module.exports = require_mixins();

package/dist/lib/model-builder.js

@@ -0,0 +1,608 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_lib_globalize = require("./globalize.js");
+const require_lib_types = require("./types.js");
+const require_lib_utils = require("./utils.js");
+const require_lib_list = require("./list.js");
+const require_lib_model = require("./model.js");
+const require_lib_model_definition = require("./model-definition.js");
+const require_lib_mixins = require("./mixins.js");
+const require_lib_introspection = require("./introspection.js");
+//#region src/lib/model-builder.ts
+var require_model_builder = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	/*!
+	* Module dependencies
+	*/
+	const g = require_lib_globalize();
+	const inflection = require("inflection");
+	const EventEmitter = require("events").EventEmitter;
+	const util = require("util");
+	const assert = require("assert");
+	const deprecated = require("depd")("loopback-datasource-juggler");
+	const DefaultModelBaseClass = require_lib_model;
+	const List = require_lib_list;
+	const ModelDefinition = require_lib_model_definition;
+	const MixinProvider = require_lib_mixins;
+	const { deepMerge, deepMergeProperty, rankArrayElements, isClass, applyParentProperty } = require_lib_utils;
+	require_lib_types(ModelBuilder);
+	const introspect = require_lib_introspection(ModelBuilder);
+	/*!
+	* Export public API
+	*/
+	exports.ModelBuilder = exports.Schema = ModelBuilder;
+	/*!
+	* Helpers
+	*/
+	const slice = Array.prototype.slice;
+	/**
+	* ModelBuilder - A builder to define data models.
+	*
+	* @property {Object} definitions Definitions of the models.
+	* @property {Object} models Model constructors
+	* @class
+	*/
+	function ModelBuilder() {
+		this.models = {};
+		this.definitions = {};
+		this.settings = {};
+		this.mixins = new MixinProvider(this);
+		this.defaultModelBaseClass = DefaultModelBaseClass;
+	}
+	util.inherits(ModelBuilder, EventEmitter);
+	ModelBuilder.defaultInstance = new ModelBuilder();
+	function isModelClass(cls) {
+		if (!cls) return false;
+		return cls.prototype instanceof DefaultModelBaseClass;
+	}
+	/**
+	* Get a model by name.
+	*
+	* @param {String} name The model name
+	* @param {Boolean} forceCreate Whether the create a stub for the given name if a model doesn't exist.
+	* @returns {ModelClass} The model class
+	*/
+	ModelBuilder.prototype.getModel = function(name, forceCreate) {
+		let model = this.models[name];
+		if (!model && forceCreate) model = this.define(name, {}, { unresolved: true });
+		return model;
+	};
+	/**
+	* Get the model definition by name
+	* @param {String} name The model name
+	* @returns {ModelDefinition} The model definition
+	*/
+	ModelBuilder.prototype.getModelDefinition = function(name) {
+		return this.definitions[name];
+	};
+	/**
+	* Define a model class.
+	* Simple example:
+	* ```
+	* var User = modelBuilder.define('User', {
+	*     email: String,
+	*     password: String,
+	*     birthDate: Date,
+	*     activated: Boolean
+	* });
+	* ```
+	* More advanced example:
+	* ```
+	* var User = modelBuilder.define('User', {
+	*     email: { type: String, limit: 150, index: true },
+	*     password: { type: String, limit: 50 },
+	*     birthDate: Date,
+	*     registrationDate: {type: Date, default: function () { return new Date }},
+	*     activated: { type: Boolean, default: false }
+	* });
+	* ```
+	*
+	* @param {String} className Name of class
+	* @param {Object} properties Hash of class properties in format `{property: Type, property2: Type2, ...}` or `{property: {type: Type}, property2: {type: Type2}, ...}`
+	* @param {Object} settings Other configuration of class
+	* @param {Function} parent Parent model
+	* @return {ModelClass} The class constructor.
+	*
+	*/
+	ModelBuilder.prototype.define = function defineClass(className, properties, settings, parent) {
+		const modelBuilder = this;
+		const args = slice.call(arguments);
+		const pluralName = settings && settings.plural || inflection.pluralize(className);
+		let pathName = (settings && settings.http || {}).path || pluralName;
+		if (!className) throw new Error(g.f("Class name required"));
+		if (args.length === 1) {
+			properties = {};
+			args.push(properties);
+		}
+		if (args.length === 2) {
+			settings = {};
+			args.push(settings);
+		}
+		properties = properties || {};
+		settings = settings || {};
+		if (settings.strict === void 0 || settings.strict === null) settings.strict = false;
+		let ModelBaseClass = parent || this.defaultModelBaseClass;
+		const baseClass = settings.base || settings["super"];
+		if (baseClass) {
+			settings.base = baseClass;
+			delete settings["super"];
+			if (isModelClass(baseClass)) ModelBaseClass = baseClass;
+			else {
+				ModelBaseClass = this.models[baseClass];
+				assert(ModelBaseClass, "Base model is not found: " + baseClass);
+			}
+		}
+		assert(ModelBaseClass.getMergePolicy, `Base class ${ModelBaseClass.modelName}
+    does not provide method getMergePolicy(). Most likely it is not inheriting
+    from datasource-juggler's built-in default ModelBaseClass, which is an
+    incorrect usage of the framework.`);
+		ModelBaseClass.__rank = ModelBaseClass.__rank || 1;
+		if (parent && !settings.base || !parent && settings.base) return ModelBaseClass.extend(className, properties, settings);
+		let ModelClass = this.models[className];
+		if (!ModelClass || !ModelClass.settings.unresolved) {
+			ModelClass = createModelClassCtor(className, ModelBaseClass);
+			const events = new EventEmitter();
+			events.setMaxListeners(32);
+			for (const f in EventEmitter.prototype) if (typeof EventEmitter.prototype[f] === "function") ModelClass[f] = EventEmitter.prototype[f].bind(events);
+			hiddenProperty(ModelClass, "modelName", className);
+		}
+		ModelClass.__rank = ModelBaseClass.__rank + 1;
+		util.inherits(ModelClass, ModelBaseClass);
+		this.models[className] = ModelClass;
+		if (settings.unresolved) {
+			ModelClass.settings = { unresolved: true };
+			return ModelClass;
+		}
+		hiddenProperty(ModelClass, "modelBuilder", modelBuilder);
+		hiddenProperty(ModelClass, "dataSource", null);
+		hiddenProperty(ModelClass, "pluralModelName", pluralName);
+		hiddenProperty(ModelClass, "relations", {});
+		if (pathName[0] !== "/") pathName = "/" + pathName;
+		hiddenProperty(ModelClass, "http", { path: pathName });
+		hiddenProperty(ModelClass, "base", ModelBaseClass);
+		hiddenProperty(ModelClass, "_observers", {});
+		hiddenProperty(ModelClass, "_warned", {});
+		for (const i in ModelBaseClass) if (i !== "_mixins" && !(i in ModelClass)) ModelClass[i] = ModelBaseClass[i];
+		if (settings.models) Object.keys(settings.models).forEach(function(m) {
+			const model = settings.models[m];
+			ModelClass[m] = typeof model === "string" ? modelBuilder.getModel(model, true) : model;
+		});
+		ModelClass.getter = {};
+		ModelClass.setter = {};
+		for (const p in properties) {
+			const excludePropertyList = settings["excludeBaseProperties"];
+			if (properties[p] === null || properties[p] === false || excludePropertyList != null && excludePropertyList.indexOf(p) != -1) delete properties[p];
+			if (/\./.test(p)) throw new Error(g.f("Property names containing dot(s) are not supported. Model: %s, property: %s", className, p));
+			if (p === "constructor") deprecated(g.f("Property name should not be \"{{constructor}}\" in Model: %s", className));
+		}
+		const modelDefinition = new ModelDefinition(this, className, properties, settings);
+		this.definitions[className] = modelDefinition;
+		ModelClass.definition = modelDefinition;
+		ModelClass.settings = modelDefinition.settings;
+		let idInjection = settings.idInjection;
+		if (idInjection !== false) idInjection = true;
+		let idNames = modelDefinition.idNames();
+		if (idNames.length > 0) idInjection = false;
+		if (idInjection) ModelClass.definition.defineProperty("id", {
+			type: Number,
+			id: 1,
+			generated: true
+		});
+		idNames = modelDefinition.idNames();
+		if (idNames.length === 1) {
+			if (idNames[0] !== "id") Object.defineProperty(ModelClass.prototype, "id", {
+				get: function() {
+					const idProp = ModelClass.definition.idNames()[0];
+					return this.__data[idProp];
+				},
+				configurable: true,
+				enumerable: false
+			});
+		} else Object.defineProperty(ModelClass.prototype, "id", {
+			get: function() {
+				const compositeId = {};
+				const idNames = ModelClass.definition.idNames();
+				for (let i = 0, p; i < idNames.length; i++) {
+					p = idNames[i];
+					compositeId[p] = this.__data[p];
+				}
+				return compositeId;
+			},
+			configurable: true,
+			enumerable: false
+		});
+		let forceId = ModelClass.settings.forceId;
+		if (idNames.length > 0) {
+			const idName = modelDefinition.idName();
+			const idProp = ModelClass.definition.rawProperties[idName];
+			if (idProp.generated && forceId !== false) forceId = "auto";
+			else if (!idProp.generated && forceId === "auto") forceId = false;
+			if (forceId) ModelClass.validatesAbsenceOf(idName, { if: "isNewRecord" });
+			ModelClass.definition.properties[idName].updateOnly = !!forceId;
+			ModelClass.definition.rawProperties[idName].updateOnly = !!forceId;
+			ModelClass.settings.forceId = forceId;
+		}
+		ModelClass.forEachProperty = function(cb) {
+			const props = ModelClass.definition.properties;
+			const keys = Object.keys(props);
+			for (let i = 0, n = keys.length; i < n; i++) cb(keys[i], props[keys[i]]);
+		};
+		ModelClass.attachTo = function(dataSource) {
+			dataSource.attach(this);
+		};
+		/** Extend the model with the specified model, properties, and other settings.
+		* For example, to extend an existing model, for example, a built-in model:
+		*
+		* ```js
+		* var Customer = User.extend('customer', {
+		*   accountId: String,
+		*   vip: Boolean
+		* });
+		* ```
+		*
+		* To extend the base model, essentially creating a new model:
+		* ```js
+		* var user = loopback.Model.extend('user', properties, options);
+		* ```
+		*
+		* @param {String} className Name of the new model being defined.
+		* @options {Object} subClassProperties child model properties, added to base model
+		*   properties.
+		* @options {Object} subClassSettings child model settings such as relations and acls,
+		*   merged with base model settings.
+		*/
+		ModelClass.extend = function(className, subClassProperties, subClassSettings) {
+			const baseClassProperties = ModelClass.definition.properties;
+			const baseClassSettings = ModelClass.definition.settings;
+			subClassProperties = subClassProperties || {};
+			subClassSettings = subClassSettings || {};
+			let idFound = false;
+			for (const k in subClassProperties) if (subClassProperties[k] && subClassProperties[k].id) {
+				idFound = true;
+				break;
+			}
+			const keys = Object.keys(baseClassProperties);
+			for (let i = 0, n = keys.length; i < n; i++) {
+				const key = keys[i];
+				if (idFound && baseClassProperties[key].id) continue;
+				if (subClassProperties[key] === void 0) {
+					const baseProp = baseClassProperties[key];
+					let basePropCopy = baseProp;
+					if (baseProp && typeof baseProp === "object") basePropCopy = deepMerge(baseProp);
+					subClassProperties[key] = basePropCopy;
+				}
+			}
+			const originalSubclassSettings = subClassSettings;
+			const mergePolicy = ModelClass.getMergePolicy(subClassSettings);
+			subClassSettings = mergeSettings(baseClassSettings, subClassSettings, mergePolicy);
+			if (!originalSubclassSettings.base) subClassSettings.base = ModelClass;
+			const subClass = modelBuilder.define(className, subClassProperties, subClassSettings, ModelClass);
+			if (typeof subClass.setup === "function") subClass.setup.call(subClass);
+			return subClass;
+		};
+		function mergeSettings(baseClassSettings, subClassSettings, mergePolicy) {
+			const mergedSettings = deepMerge(baseClassSettings);
+			Object.keys(baseClassSettings).forEach(function(key) {
+				if (mergePolicy[key] && mergePolicy[key].rank) baseClassSettings[key] = rankArrayElements(baseClassSettings[key], ModelBaseClass.__rank);
+			});
+			Object.keys(subClassSettings).forEach(function(key) {
+				if (mergePolicy[key] == null) mergePolicy[key] = mergePolicy.__default || {};
+				if (subClassSettings[key] === mergePolicy.__delete) {
+					delete mergedSettings[key];
+					return;
+				}
+				if (mergePolicy[key].rank) subClassSettings[key] = rankArrayElements(subClassSettings[key], ModelBaseClass.__rank + 1);
+				if (mergePolicy[key].replace) {
+					mergedSettings[key] = subClassSettings[key];
+					return;
+				}
+				if (mergePolicy[key].patch) {
+					mergedSettings[key] = mergedSettings[key] || {};
+					Object.keys(subClassSettings[key]).forEach(function(innerKey) {
+						mergedSettings[key][innerKey] = subClassSettings[key][innerKey];
+					});
+					return;
+				}
+				mergedSettings[key] = deepMergeProperty(baseClassSettings[key], subClassSettings[key]);
+			});
+			return mergedSettings;
+		}
+		/**
+		* Register a property for the model class
+		* @param {String} propertyName Name of the property.
+		*/
+		ModelClass.registerProperty = function(propertyName) {
+			const properties = modelDefinition.build();
+			const prop = properties[propertyName];
+			const DataType = prop.type;
+			if (!DataType) throw new Error(g.f("Invalid type for property %s", propertyName));
+			if (prop.required) {
+				const requiredOptions = typeof prop.required === "object" ? prop.required : void 0;
+				ModelClass.validatesPresenceOf(propertyName, requiredOptions);
+			}
+			if (DataType === Date) ModelClass.validatesDateOf(propertyName);
+			Object.defineProperty(ModelClass.prototype, propertyName, {
+				get: function() {
+					if (ModelClass.getter[propertyName]) return ModelClass.getter[propertyName].call(this);
+					else return this.__data && this.__data[propertyName];
+				},
+				set: function(value) {
+					let DataType = ModelClass.definition.properties[propertyName].type;
+					if (Array.isArray(DataType) || DataType === Array) DataType = List;
+					else if (DataType === Date) DataType = DateType;
+					else if (DataType === Boolean) DataType = BooleanType;
+					else if (typeof DataType === "string") DataType = modelBuilder.resolveType(DataType);
+					const persistUndefinedAsNull = ModelClass.definition.settings.persistUndefinedAsNull;
+					if (value === void 0 && persistUndefinedAsNull) value = null;
+					if (ModelClass.setter[propertyName]) ModelClass.setter[propertyName].call(this, value);
+					else {
+						this.__data = this.__data || {};
+						if (value === null || value === void 0) this.__data[propertyName] = value;
+						else if (DataType === List) this.__data[propertyName] = isClass(DataType) ? new DataType(value, properties[propertyName].type, this) : DataType(value, properties[propertyName].type, this);
+						else {
+							this.__data[propertyName] = value instanceof DataType ? value : isClass(DataType) ? new DataType(value) : DataType(value);
+							if (value && this.__data[propertyName] instanceof DefaultModelBaseClass) applyParentProperty(this.__data[propertyName], this);
+						}
+					}
+				},
+				configurable: true,
+				enumerable: true
+			});
+			Object.defineProperty(ModelClass.prototype, "$" + propertyName, {
+				get: function() {
+					return this.__data && this.__data[propertyName];
+				},
+				set: function(value) {
+					if (!this.__data) this.__data = {};
+					this.__data[propertyName] = value;
+				},
+				configurable: true,
+				enumerable: false
+			});
+		};
+		const props = ModelClass.definition.properties;
+		let keys = Object.keys(props);
+		let size = keys.length;
+		for (let i = 0; i < size; i++) {
+			const propertyName = keys[i];
+			ModelClass.registerProperty(propertyName);
+		}
+		const mixinSettings = settings.mixins || {};
+		keys = Object.keys(mixinSettings);
+		size = keys.length;
+		for (let i = 0; i < size; i++) {
+			const name = keys[i];
+			let mixin = mixinSettings[name];
+			if (mixin === true) mixin = {};
+			if (Array.isArray(mixin)) mixin.forEach(function(m) {
+				if (m === true) m = {};
+				if (typeof m === "object") modelBuilder.mixins.applyMixin(ModelClass, name, m);
+			});
+			else if (typeof mixin === "object") modelBuilder.mixins.applyMixin(ModelClass, name, mixin);
+		}
+		ModelClass.emit("defined", ModelClass);
+		return ModelClass;
+	};
+	function createModelClassCtor(name, ModelBaseClass) {
+		name = name.replace(/[-.:]/g, "_");
+		try {
+			return new Function("ModelBaseClass", `
+      // every class can receive hash of data as optional param
+      return function ${name}(data, options) {
+        if (!(this instanceof ${name})) {
+          return new ${name}(data, options);
+        }
+        if (${name}.settings.unresolved) {
+          throw new Error(g.f('Model %s is not defined.', ${JSON.stringify(name)}));
+        }
+        ModelBaseClass.apply(this, arguments);
+      };`)(ModelBaseClass);
+		} catch (err) {
+			if (err.name === "SyntaxError") return createModelClassCtor("ModelConstructor", ModelBaseClass);
+			else throw err;
+		}
+	}
+	function DateType(arg) {
+		if (arg === null) return null;
+		return new Date(arg);
+	}
+	function BooleanType(arg) {
+		if (typeof arg === "string") switch (arg) {
+			case "true":
+			case "1": return true;
+			case "false":
+			case "0": return false;
+		}
+		if (arg == null) return null;
+		return Boolean(arg);
+	}
+	/**
+	* Define single property named `propertyName` on `model`
+	*
+	* @param {String} model Name of model
+	* @param {String} propertyName Name of property
+	* @param {Object} propertyDefinition Property settings
+	*/
+	ModelBuilder.prototype.defineProperty = function(model, propertyName, propertyDefinition) {
+		this.definitions[model].defineProperty(propertyName, propertyDefinition);
+		this.models[model].registerProperty(propertyName);
+	};
+	/**
+	* Define a new value type that can be used in model schemas as a property type.
+	* @param {function()} type Type constructor.
+	* @param {string[]=} aliases Optional list of alternative names for this type.
+	*/
+	ModelBuilder.prototype.defineValueType = function(type, aliases) {
+		ModelBuilder.registerType(type, aliases);
+	};
+	/**
+	* Extend existing model with specified properties
+	*
+	* Example:
+	* Instead of extending a model with attributes like this (for example):
+	*
+	* ```js
+	*     db.defineProperty('Content', 'competitionType',
+	*       { type: String });
+	*     db.defineProperty('Content', 'expiryDate',
+	*       { type: Date, index: true });
+	*     db.defineProperty('Content', 'isExpired',
+	*       { type: Boolean, index: true });
+	*```
+	* This method enables you to extend a model as follows (for example):
+	* ```js
+	*     db.extendModel('Content', {
+	*       competitionType: String,
+	*       expiryDate: { type: Date, index: true },
+	*       isExpired: { type: Boolean, index: true }
+	*     });
+	*```
+	*
+	* @param {String} model Name of model
+	* @options {Object} properties JSON object specifying properties.  Each property is a key whos value is
+	* either the [type](http://docs.strongloop.com/display/LB/LoopBack+types) or `propertyName: {options}`
+	* where the options are described below.
+	* @property {String} type Datatype of property: Must be an [LDL type](http://docs.strongloop.com/display/LB/LoopBack+types).
+	* @property {Boolean} index True if the property is an index; false otherwise.
+	*/
+	ModelBuilder.prototype.extendModel = function(model, props) {
+		const t = this;
+		const keys = Object.keys(props);
+		for (let i = 0; i < keys.length; i++) {
+			const definition = props[keys[i]];
+			t.defineProperty(model, keys[i], definition);
+		}
+	};
+	ModelBuilder.prototype.copyModel = function copyModel(Master) {
+		const modelBuilder = this;
+		const className = Master.modelName;
+		const md = Master.modelBuilder.definitions[className];
+		const Slave = function SlaveModel() {
+			Master.apply(this, [].slice.call(arguments));
+		};
+		util.inherits(Slave, Master);
+		Slave.__proto__ = Master;
+		hiddenProperty(Slave, "modelBuilder", modelBuilder);
+		hiddenProperty(Slave, "modelName", className);
+		hiddenProperty(Slave, "relations", Master.relations);
+		if (!(className in modelBuilder.models)) {
+			modelBuilder.models[className] = Slave;
+			modelBuilder.definitions[className] = {
+				properties: md.properties,
+				settings: md.settings
+			};
+		}
+		return Slave;
+	};
+	/**
+	* Remove a model from the registry.
+	*
+	* @param {String} modelName
+	*/
+	ModelBuilder.prototype.deleteModelByName = function(modelName) {
+		delete this.models[modelName];
+		delete this.definitions[modelName];
+	};
+	/*!
+	* Define hidden property
+	*/
+	function hiddenProperty(where, property, value) {
+		Object.defineProperty(where, property, {
+			writable: true,
+			enumerable: false,
+			configurable: true,
+			value
+		});
+	}
+	/**
+	* Get the schema name. If no parameter is given, then an anonymous model name
+	* is generated and returned.
+	* @param {string=} name The optional name parameter.
+	* @returns {string} The schema name.
+	*/
+	ModelBuilder.prototype.getSchemaName = function(name) {
+		if (name) return name;
+		if (typeof this._nameCount !== "number") this._nameCount = 0;
+		else this._nameCount++;
+		return "AnonymousModel_" + this._nameCount;
+	};
+	/**
+	* Resolve the type string to be a function, for example, 'String' to String.
+	* Returns {Function} if the type is resolved
+	* @param {String | Object | Array} prop The object whose type is to be resolved
+	*/
+	ModelBuilder.prototype.resolveType = function(prop, isSubProperty) {
+		if (!prop) return prop;
+		if (Array.isArray(prop) && prop.length > 0) {
+			const itemType = this.resolveType(prop[0]);
+			if (typeof itemType === "function") return [itemType];
+			else return itemType;
+		}
+		if (typeof prop === "string") {
+			const schemaType = ModelBuilder.schemaTypes[prop.toLowerCase()] || this.models[prop];
+			if (schemaType) return schemaType;
+			else {
+				prop = this.define(prop, {}, { unresolved: true });
+				return prop;
+			}
+		} else if (prop.constructor.name === "Object") if (!isSubProperty && prop.type) return this.resolveType(prop.type, true);
+		else return this.define(this.getSchemaName(null), prop, {
+			anonymous: true,
+			idInjection: false,
+			strict: this.settings.strictEmbeddedModels || false
+		});
+		else if ("function" === typeof prop) return prop;
+		return prop;
+	};
+	/**
+	* Build models from schema definitions
+	*
+	* `schemas` can be one of the following:
+	*
+	* 1. An array of named schema definition JSON objects
+	* 2. A schema definition JSON object
+	* 3. A list of property definitions (anonymous)
+	*
+	* @param {*} schemas The schemas
+	* @returns {Object.<string, ModelClass>} A map of model constructors keyed by
+	* model name.
+	*/
+	ModelBuilder.prototype.buildModels = function(schemas, createModel) {
+		const models = {};
+		if (!Array.isArray(schemas)) if (schemas.properties && schemas.name) schemas = [schemas];
+		else schemas = [{
+			name: this.getSchemaName(),
+			properties: schemas,
+			options: { anonymous: true }
+		}];
+		let relations = [];
+		for (let s = 0, n = schemas.length; s < n; s++) {
+			const name = this.getSchemaName(schemas[s].name);
+			schemas[s].name = name;
+			const model = typeof createModel === "function" ? createModel(schemas[s].name, schemas[s].properties, schemas[s].options) : this.define(schemas[s].name, schemas[s].properties, schemas[s].options);
+			models[name] = model;
+			relations = relations.concat(model.definition.relations);
+		}
+		for (let i = 0; i < relations.length; i++) {
+			const relation = relations[i];
+			const sourceModel = models[relation.source];
+			const targetModel = models[relation.target];
+			if (sourceModel && targetModel) {
+				if (typeof sourceModel[relation.type] === "function") sourceModel[relation.type](targetModel, { as: relation.as });
+			}
+		}
+		return models;
+	};
+	/**
+	* Introspect the JSON document to build a corresponding model.
+	* @param {String} name The model name
+	* @param {Object} json The JSON object
+	* @param {Object} options The options
+	* @returns {ModelClass} The generated model class constructor.
+	*/
+	ModelBuilder.prototype.buildModelFromInstance = function(name, json, options) {
+		const schema = introspect(json);
+		return this.define(name, schema, options);
+	};
+}));
+//#endregion
+module.exports = require_model_builder();