@vsaas/loopback-datasource-juggler 10.0.0

package/dist/lib/include_utils.js

@@ -0,0 +1,104 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_lib_globalize = require("./globalize.js");
+//#region src/lib/include_utils.ts
+var require_include_utils = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const g = require_lib_globalize();
+	module.exports.buildOneToOneIdentityMapWithOrigKeys = buildOneToOneIdentityMapWithOrigKeys;
+	module.exports.buildOneToManyIdentityMapWithOrigKeys = buildOneToManyIdentityMapWithOrigKeys;
+	module.exports.join = join;
+	module.exports.KVMap = KVMap;
+	function getId(obj, idName) {
+		const id = obj && obj[idName];
+		if (id == null) {
+			const msg = g.f("ID property \"%s\" is missing for included item: %j. Please make sure `fields` include \"%s\" if it's present in the `filter`", idName, obj, idName);
+			const err = new Error(msg);
+			err.statusCode = 400;
+			throw err;
+		}
+		return id;
+	}
+	/**
+	* Effectively builds associative map on id -> object relation and stores original keys.
+	* Map returned in form of object with ids in keys and object as values.
+	* @param objs array of objects to build from
+	* @param idName name of property to be used as id. Such property considered to be unique across array.
+	* In case of collisions last wins. For non-unique ids use buildOneToManyIdentityMap()
+	* @returns {} object where keys are ids and values are objects itself
+	*/
+	function buildOneToOneIdentityMapWithOrigKeys(objs, idName) {
+		const kvMap = new KVMap();
+		for (let i = 0; i < objs.length; i++) {
+			const obj = objs[i];
+			const id = getId(obj, idName);
+			kvMap.set(id, obj);
+		}
+		return kvMap;
+	}
+	function buildOneToManyIdentityMapWithOrigKeys(objs, idName) {
+		const kvMap = new KVMap();
+		for (let i = 0; i < objs.length; i++) {
+			const obj = objs[i];
+			const id = getId(obj, idName);
+			const value = kvMap.get(id) || [];
+			value.push(obj);
+			kvMap.set(id, value);
+		}
+		return kvMap;
+	}
+	/**
+	* Yeah, it joins. You need three things id -> obj1 map, id -> [obj2] map and merge function.
+	* This functions will take each obj1, locate all data to join in map2 and call merge function.
+	* @param oneToOneIdMap
+	* @param oneToManyIdMap
+	* @param mergeF  function(obj, objectsToMergeIn)
+	*/
+	function join(oneToOneIdMap, oneToManyIdMap, mergeF) {
+		const ids = oneToOneIdMap.getKeys();
+		for (let i = 0; i < ids.length; i++) {
+			const id = ids[i];
+			mergeF(oneToOneIdMap.get(id), oneToManyIdMap.get(id) || []);
+		}
+	}
+	/**
+	* Map with arbitrary keys and values. User .set() and .get() to work with values instead of []
+	* @returns {{set: Function, get: Function, remove: Function, exist: Function, getKeys: Function}}
+	* @constructor
+	*/
+	function KVMap() {
+		const _originalKeyFieldName = "originalKey";
+		const _valueKeyFieldName = "value";
+		const _dict = {};
+		const keyToString = function(key) {
+			return key.toString();
+		};
+		return {
+			set: function(key, value) {
+				const recordObj = {};
+				recordObj[_originalKeyFieldName] = key;
+				recordObj[_valueKeyFieldName] = value;
+				_dict[keyToString(key)] = recordObj;
+				return true;
+			},
+			get: function(key) {
+				const storeObj = _dict[keyToString(key)];
+				if (storeObj) return storeObj[_valueKeyFieldName];
+				else return;
+			},
+			remove: function(key) {
+				delete _dict[keyToString(key)];
+				return true;
+			},
+			exist: function(key) {
+				return _dict.hasOwnProperty(keyToString(key));
+			},
+			getKeys: function() {
+				const result = [];
+				for (const key in _dict) result.push(_dict[key][_originalKeyFieldName]);
+				return result;
+			}
+		};
+	}
+}));
+//#endregion
+module.exports = require_include_utils();

package/dist/lib/introspection.js

@@ -0,0 +1,37 @@
+"use strict";
+//#region src/lib/introspection.ts
+var require_introspection = /* @__PURE__ */ require("../_virtual/_rolldown/runtime.js").__commonJSMin(((exports, module) => {
+	module.exports = function getIntrospector(ModelBuilder) {
+		function introspectType(value) {
+			if (value === null || value === void 0) return ModelBuilder.Any;
+			for (const t in ModelBuilder.schemaTypes) {
+				const st = ModelBuilder.schemaTypes[t];
+				if (st !== Object && st !== Array && value instanceof st) return t;
+			}
+			const type = typeof value;
+			if (type === "string" || type === "number" || type === "boolean") return type;
+			if (value instanceof Date) return "date";
+			let itemType;
+			if (Array.isArray(value)) {
+				for (let i = 0; i < value.length; i++) {
+					if (value[i] === null || value[i] === void 0) continue;
+					itemType = introspectType(value[i]);
+					if (itemType) return [itemType];
+				}
+				return "array";
+			}
+			if (type === "function") return value.constructor.name;
+			const properties = {};
+			for (const p in value) {
+				itemType = introspectType(value[p]);
+				if (itemType) properties[p] = itemType;
+			}
+			if (Object.keys(properties).length === 0) return "object";
+			return properties;
+		}
+		ModelBuilder.introspect = introspectType;
+		return introspectType;
+	};
+}));
+//#endregion
+module.exports = require_introspection();

package/dist/lib/jutil.js

@@ -0,0 +1,65 @@
+"use strict";
+//#region src/lib/jutil.ts
+var require_jutil = /* @__PURE__ */ require("../_virtual/_rolldown/runtime.js").__commonJSMin(((exports) => {
+	const util = require("util");
+	/**
+	*
+	* @param newClass
+	* @param baseClass
+	*/
+	exports.inherits = function(newClass, baseClass, options) {
+		util.inherits(newClass, baseClass);
+		options = options || {
+			staticProperties: true,
+			override: false
+		};
+		if (options.staticProperties) Object.keys(baseClass).forEach(function(classProp) {
+			if (classProp !== "super_" && (!newClass.hasOwnProperty(classProp) || options.override)) Object.defineProperty(newClass, classProp, Object.getOwnPropertyDescriptor(baseClass, classProp));
+		});
+	};
+	/**
+	* Mix in the a class into the new class
+	* @param newClass The target class to receive the mixin
+	* @param mixinClass The class to be mixed in
+	* @param options
+	*/
+	exports.mixin = function(newClass, mixinClass, options) {
+		if (Array.isArray(newClass._mixins)) {
+			if (newClass._mixins.indexOf(mixinClass) !== -1) return;
+			newClass._mixins.push(mixinClass);
+		} else newClass._mixins = [mixinClass];
+		options = options || {
+			staticProperties: true,
+			instanceProperties: true,
+			override: false,
+			proxyFunctions: false
+		};
+		if (options.staticProperties === void 0) options.staticProperties = true;
+		if (options.instanceProperties === void 0) options.instanceProperties = true;
+		if (options.staticProperties) mixInto(mixinClass, newClass, options);
+		if (options.instanceProperties && mixinClass.prototype) mixInto(mixinClass.prototype, newClass.prototype, options);
+		return newClass;
+	};
+	function mixInto(sourceScope, targetScope, options) {
+		Object.keys(sourceScope).forEach(function(propertyName) {
+			const targetPropertyExists = targetScope.hasOwnProperty(propertyName);
+			const sourceProperty = Object.getOwnPropertyDescriptor(sourceScope, propertyName);
+			const targetProperty = targetPropertyExists && Object.getOwnPropertyDescriptor(targetScope, propertyName);
+			const isDelegate = targetPropertyExists && typeof targetProperty.value === "function" && targetProperty.value._delegate;
+			const shouldOverride = options.override || !targetPropertyExists || isDelegate;
+			if (propertyName == "_mixins") {
+				mergeMixins(sourceScope._mixins, targetScope._mixins);
+				return;
+			}
+			if (shouldOverride) Object.defineProperty(targetScope, propertyName, sourceProperty);
+		});
+	}
+	function mergeMixins(source, target) {
+		for (const ix in source) {
+			const mx = source[ix];
+			if (target.indexOf(mx) === -1) target.push(mx);
+		}
+	}
+}));
+//#endregion
+module.exports = require_jutil();

package/dist/lib/kvao/delete-all.js

@@ -0,0 +1,57 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+const require_lib_utils = require("../utils.js");
+//#region src/lib/kvao/delete-all.ts
+var require_delete_all = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const assert = require("assert");
+	const debug = require("debug")("loopback:kvao:delete-all");
+	const utils = require_lib_utils;
+	/**
+	* Delete all keys (and values) associated to the current model.
+	*
+	* @options {Object} options Unused ATM, placeholder for future options.
+	* @callback {Function} callback
+	* @param {Error} err Error object.
+	* @promise
+	*
+	* @header KVAO.prototype.deleteAll([options, ]cb)
+	*/
+	module.exports = function deleteAll(options, callback) {
+		if (callback == void 0 && typeof options === "function") {
+			callback = options;
+			options = {};
+		} else if (!options) options = {};
+		assert(typeof options === "object", "options must be an object");
+		callback = callback || utils.createPromiseCallback();
+		const connector = this.getConnector();
+		if (typeof connector.deleteAll === "function") connector.deleteAll(this.modelName, options, callback);
+		else if (typeof connector.delete === "function") {
+			debug("Falling back to unoptimized key-value pair deletion");
+			iterateAndDelete(connector, this.modelName, options, callback);
+		} else {
+			const errMsg = "Connector does not support key-value pair deletion";
+			debug(errMsg);
+			process.nextTick(function() {
+				const err = new Error(errMsg);
+				err.statusCode = 501;
+				callback(err);
+			});
+		}
+		return callback.promise;
+	};
+	function iterateAndDelete(connector, modelName, options, callback) {
+		const iter = connector.iterateKeys(modelName, {});
+		iter.next(onNextKey);
+		function onNextKey(err, key) {
+			if (err) return callback(err);
+			if (key === void 0) return callback();
+			connector.delete(modelName, key, options, onDeleted);
+		}
+		function onDeleted(err) {
+			if (err) return callback(err);
+			iter.next(onNextKey);
+		}
+	}
+}));
+//#endregion
+module.exports = require_delete_all();

package/dist/lib/kvao/delete.js

@@ -0,0 +1,43 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+const require_lib_utils = require("../utils.js");
+//#region src/lib/kvao/delete.ts
+var require_delete = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const assert = require("assert");
+	const debug = require("debug")("loopback:kvao:delete");
+	const utils = require_lib_utils;
+	/**
+	* Delete the key-value pair associated to the given key.
+	*
+	* @param {String} key Key to use when searching the database.
+	* @options {Object} options
+	* @callback {Function} callback
+	* @param {Error} err Error object.
+	* @param {*} result Value associated with the given key.
+	* @promise
+	*
+	* @header KVAO.prototype.delete(key[, options], cb)
+	*/
+	module.exports = function keyValueDelete(key, options, callback) {
+		if (callback == void 0 && typeof options === "function") {
+			callback = options;
+			options = {};
+		} else if (!options) options = {};
+		assert(typeof key === "string" && key, "key must be a non-empty string");
+		callback = callback || utils.createPromiseCallback();
+		const connector = this.getConnector();
+		if (typeof connector.delete === "function") connector.delete(this.modelName, key, options, callback);
+		else {
+			const errMsg = "Connector does not support key-value pair deletion";
+			debug(errMsg);
+			process.nextTick(function() {
+				const err = new Error(errMsg);
+				err.statusCode = 501;
+				callback(err);
+			});
+		}
+		return callback.promise;
+	};
+}));
+//#endregion
+module.exports = require_delete();

package/dist/lib/kvao/expire.js

@@ -0,0 +1,35 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+const require_lib_utils = require("../utils.js");
+//#region src/lib/kvao/expire.ts
+var require_expire = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const assert = require("assert");
+	const utils = require_lib_utils;
+	/**
+	* Set the TTL (time to live) in ms (milliseconds) for a given key. TTL is the
+	* remaining time before a key-value pair is discarded from the database.
+	*
+	* @param {String} key Key to use when searching the database.
+	* @param {Number} ttl TTL in ms to set for the key.
+	* @options {Object} options
+	* @callback {Function} callback
+	* @param {Error} err Error object.
+	* @promise
+	*
+	* @header KVAO.expire(key, ttl, cb)
+	*/
+	module.exports = function keyValueExpire(key, ttl, options, callback) {
+		if (callback == void 0 && typeof options === "function") {
+			callback = options;
+			options = {};
+		} else if (!options) options = {};
+		assert(typeof key === "string" && key, "key must be a non-empty string");
+		assert(typeof ttl === "number" && ttl > 0, "ttl must be a positive integer");
+		assert(typeof options === "object", "options must be an object");
+		callback = callback || utils.createPromiseCallback();
+		this.getConnector().expire(this.modelName, key, ttl, options, callback);
+		return callback.promise;
+	};
+}));
+//#endregion
+module.exports = require_expire();

package/dist/lib/kvao/get.js

@@ -0,0 +1,34 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+const require_lib_utils = require("../utils.js");
+//#region src/lib/kvao/get.ts
+var require_get = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const assert = require("assert");
+	const utils = require_lib_utils;
+	/**
+	* Return the value associated with a given key.
+	*
+	* @param {String} key Key to use when searching the database.
+	* @options {Object} options
+	* @callback {Function} callback
+	* @param {Error} err Error object.
+	* @param {*} result Value associated with the given key.
+	* @promise
+	*
+	* @header KVAO.get(key, cb)
+	*/
+	module.exports = function keyValueGet(key, options, callback) {
+		if (callback == void 0 && typeof options === "function") {
+			callback = options;
+			options = {};
+		} else if (!options) options = {};
+		assert(typeof key === "string" && key, "key must be a non-empty string");
+		callback = callback || utils.createPromiseCallback();
+		this.getConnector().get(this.modelName, key, options, function(err, result) {
+			callback(err, result);
+		});
+		return callback.promise;
+	};
+}));
+//#endregion
+module.exports = require_get();

package/dist/lib/kvao/index.js

@@ -0,0 +1,28 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+const require_lib_kvao_delete = require("./delete.js");
+const require_lib_kvao_delete_all = require("./delete-all.js");
+const require_lib_kvao_get = require("./get.js");
+const require_lib_kvao_set = require("./set.js");
+const require_lib_kvao_expire = require("./expire.js");
+const require_lib_kvao_ttl = require("./ttl.js");
+const require_lib_kvao_iterate_keys = require("./iterate-keys.js");
+const require_lib_kvao_keys = require("./keys.js");
+//#region src/lib/kvao/index.ts
+var require_kvao = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	function KeyValueAccessObject() {}
+	module.exports = KeyValueAccessObject;
+	KeyValueAccessObject.delete = require_lib_kvao_delete;
+	KeyValueAccessObject.deleteAll = require_lib_kvao_delete_all;
+	KeyValueAccessObject.get = require_lib_kvao_get;
+	KeyValueAccessObject.set = require_lib_kvao_set;
+	KeyValueAccessObject.expire = require_lib_kvao_expire;
+	KeyValueAccessObject.ttl = require_lib_kvao_ttl;
+	KeyValueAccessObject.iterateKeys = require_lib_kvao_iterate_keys;
+	KeyValueAccessObject.keys = require_lib_kvao_keys;
+	KeyValueAccessObject.getConnector = function() {
+		return this.getDataSource().connector;
+	};
+}));
+//#endregion
+module.exports = require_kvao();

package/dist/lib/kvao/iterate-keys.js

@@ -0,0 +1,38 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+const require_lib_utils = require("../utils.js");
+//#region src/lib/kvao/iterate-keys.ts
+var require_iterate_keys = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const assert = require("assert");
+	const utils = require_lib_utils;
+	/**
+	* Asynchronously iterate all keys in the database. Similar to `.keys()` but
+	* instead allows for iteration over large data sets without having to load
+	* everything into memory at once.
+	*
+	* @param {Object} filter An optional filter object with the following
+	* @param {String} filter.match Glob string to use to filter returned
+	*   keys (i.e. `userid.*`). All connectors are required to support `*` and
+	*   `?`. They may also support additional special characters that are
+	*   specific to the backing database.
+	* @param {Object} options
+	* @returns {AsyncIterator} An Object implementing `next(cb) -> Promise`
+	*   function that can be used to iterate all keys.
+	*
+	* @header KVAO.iterateKeys(filter)
+	*/
+	module.exports = function keyValueIterateKeys(filter, options) {
+		filter = filter || {};
+		options = options || {};
+		assert(typeof filter === "object", "filter must be an object");
+		assert(typeof options === "object", "options must be an object");
+		const iter = this.getConnector().iterateKeys(this.modelName, filter, options);
+		return { next: function(callback) {
+			callback = callback || utils.createPromiseCallback();
+			iter.next(callback);
+			return callback.promise;
+		} };
+	};
+}));
+//#endregion
+module.exports = require_iterate_keys();

package/dist/lib/kvao/keys.js

@@ -0,0 +1,55 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+const require_lib_utils = require("../utils.js");
+//#region src/lib/kvao/keys.ts
+var require_keys = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const assert = require("assert");
+	const utils = require_lib_utils;
+	/**
+	* Return all keys in the database.
+	*
+	* **WARNING**: This method is not suitable for large data sets as all
+	* key-values pairs are loaded into memory at once. For large data sets,
+	* use `iterateKeys()` instead.
+	*
+	* @param {Object} filter An optional filter object with the following
+	* @param {String} filter.match Glob string used to filter returned
+	*   keys (i.e. `userid.*`). All connectors are required to support `*` and
+	*   `?`, but may also support additional special characters specific to the
+	*   database.
+	* @param {Object} options
+	* @callback {Function} callback
+	* @promise
+	*
+	*
+	* @header KVAO.keys(filter, callback)
+	*/
+	module.exports = function keyValueKeys(filter, options, callback) {
+		if (callback === void 0) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			} else if (options === void 0 && typeof filter === "function") {
+				callback = filter;
+				filter = void 0;
+			}
+		}
+		filter = filter || {};
+		options = options || {};
+		assert(typeof filter === "object", "filter must be an object");
+		assert(typeof options === "object", "options must be an object");
+		callback = callback || utils.createPromiseCallback();
+		const iter = this.iterateKeys(filter, options);
+		const keys = [];
+		iter.next(onNextKey);
+		function onNextKey(err, key) {
+			if (err) return callback(err);
+			if (key === void 0) return callback(null, keys);
+			keys.push(key);
+			iter.next(onNextKey);
+		}
+		return callback.promise;
+	};
+}));
+//#endregion
+module.exports = require_keys();

package/dist/lib/kvao/set.js

@@ -0,0 +1,39 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+const require_lib_utils = require("../utils.js");
+//#region src/lib/kvao/set.ts
+var require_set = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const assert = require("assert");
+	const utils = require_lib_utils;
+	/**
+	* Persist a value and associate it with the given key.
+	*
+	* @param {String} key Key to associate with the given value.
+	* @param {*} value Value to persist.
+	* @options {Number|Object} options Optional settings for the key-value
+	*   pair. If a Number is provided, it is set as the TTL (time to live) in ms
+	*   (milliseconds) for the key-value pair.
+	* @property {Number} ttl TTL for the key-value pair in ms.
+	* @callback {Function} callback
+	* @param {Error} err Error object.
+	* @promise
+	*
+	* @header KVAO.set(key, value, cb)
+	*/
+	module.exports = function keyValueSet(key, value, options, callback) {
+		if (callback == void 0 && typeof options === "function") {
+			callback = options;
+			options = {};
+		} else if (typeof options === "number") options = { ttl: options };
+		else if (!options) options = {};
+		assert(typeof key === "string" && key, "key must be a non-empty string");
+		assert(value != null, "value must be defined and not null");
+		assert(typeof options === "object", "options must be an object");
+		if (options && "ttl" in options) assert(typeof options.ttl === "number" && options.ttl > 0, "options.ttl must be a positive number");
+		callback = callback || utils.createPromiseCallback();
+		this.getConnector().set(this.modelName, key, value, options, callback);
+		return callback.promise;
+	};
+}));
+//#endregion
+module.exports = require_set();

package/dist/lib/kvao/ttl.js

@@ -0,0 +1,35 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+const require_lib_utils = require("../utils.js");
+//#region src/lib/kvao/ttl.ts
+var require_ttl = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const assert = require("assert");
+	const utils = require_lib_utils;
+	/**
+	* Return the TTL (time to live) for a given key. TTL is the remaining time
+	* before a key-value pair is discarded from the database.
+	*
+	* @param {String} key Key to use when searching the database.
+	* @options {Object} options
+	* @callback {Function} callback
+	* @param {Error} error
+	* @param {Number} ttl Expiration time for the key-value pair. `undefined` if
+	*   TTL was not initially set.
+	* @promise
+	*
+	* @header KVAO.ttl(key, cb)
+	*/
+	module.exports = function keyValueTtl(key, options, callback) {
+		if (callback == void 0 && typeof options === "function") {
+			callback = options;
+			options = {};
+		} else if (!options) options = {};
+		assert(typeof key === "string" && key, "key must be a non-empty string");
+		assert(typeof options === "object", "options must be an object");
+		callback = callback || utils.createPromiseCallback();
+		this.getConnector().ttl(this.modelName, key, options, callback);
+		return callback.promise;
+	};
+}));
+//#endregion
+module.exports = require_ttl();

package/dist/lib/list.js

@@ -0,0 +1,101 @@
+"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");
+//#region src/lib/list.ts
+var require_list = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const g = require_lib_globalize();
+	const util = require("util");
+	const Any = require_lib_types.Types.Any;
+	const { applyParentProperty } = require_lib_utils;
+	module.exports = List;
+	function List(items, itemType, parent) {
+		if (!(this instanceof List)) return new List(items, itemType, parent);
+		if (typeof items === "string") try {
+			items = JSON.parse(items);
+		} catch {
+			const err = new Error(g.f("could not create List from JSON string: %j", items));
+			err.statusCode = 400;
+			throw err;
+		}
+		if (typeof items === "number") items = Array.from({ length: items });
+		const arr = [];
+		arr.__proto__ = List.prototype;
+		items = items || [];
+		if (!Array.isArray(items)) {
+			const err = new Error(g.f("Items must be an array: %j", items));
+			err.statusCode = 400;
+			throw err;
+		}
+		if (!itemType) itemType = items[0] && items[0].constructor;
+		if (Array.isArray(itemType)) itemType = itemType[0];
+		if (itemType === Array) itemType = Any;
+		Object.defineProperty(arr, "itemType", {
+			writable: true,
+			enumerable: false,
+			value: itemType
+		});
+		if (parent) Object.defineProperty(arr, "parent", {
+			writable: true,
+			enumerable: false,
+			value: parent
+		});
+		items.forEach(function(item, i) {
+			if (itemType && !(item instanceof itemType)) arr[i] = arr.toItem(item);
+			else arr[i] = item;
+			if (parent && arr[i] && typeof arr[i] === "object") applyParentProperty(arr[i], parent);
+		});
+		return arr;
+	}
+	util.inherits(List, Array);
+	const _push = List.prototype.push;
+	List.prototype.toItem = function(item) {
+		if (isClass(this.itemType)) return new this.itemType(item);
+		else if (Array.isArray(item)) return item;
+		else if (this.itemType === Date) {
+			if (item === null) return null;
+			return new Date(item);
+		} else return this.itemType(item);
+	};
+	List.prototype.push = function(obj) {
+		const item = this.itemType && obj instanceof this.itemType ? obj : this.toItem(obj);
+		if (item && typeof item === "object" && this.parent) applyParentProperty(item, this.parent);
+		_push.call(this, item);
+		return item;
+	};
+	List.prototype.toObject = function(onlySchema, removeHidden, removeProtected) {
+		const items = [];
+		this.forEach(function(item) {
+			if (item && Array.isArray(item) && item.toArray) {
+				const subArray = item.toArray();
+				items.push(subArray);
+			} else if (item && typeof item === "object" && item.toObject) items.push(item.toObject(onlySchema, removeHidden, removeProtected));
+			else items.push(item);
+		});
+		return items;
+	};
+	/**
+	* Convert itself to a plain array.
+	*
+	* Some modules such as `should` checks prototype for comparison
+	*/
+	List.prototype.toArray = function() {
+		const items = [];
+		this.forEach(function(item) {
+			items.push(item);
+		});
+		return items;
+	};
+	List.prototype.toJSON = function() {
+		return this.toObject(true);
+	};
+	List.prototype.toString = function() {
+		return JSON.stringify(this.toJSON());
+	};
+	function isClass(fn) {
+		return fn && fn.toString().indexOf("class ") === 0;
+	}
+}));
+//#endregion
+module.exports = require_list();