@vsaas/loopback 10.0.0

package/dist/lib/registry.cjs

@@ -0,0 +1,291 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_lib_globalize = require("./globalize.cjs");
+const require_lib_model = require("./model.cjs");
+const require_lib_persisted_model = require("./persisted-model.cjs");
+//#region src/lib/registry.ts
+var require_registry = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const g = require_lib_globalize;
+	const assert = require("assert");
+	const juggler = require("@vsaas/loopback-datasource-juggler");
+	const debug = require("debug")("loopback:registry");
+	const DataSource = juggler.DataSource;
+	const ModelBuilder = juggler.ModelBuilder;
+	const deprecated = require("depd")("strong-remoting");
+	module.exports = Registry;
+	/**
+	* Define and reference `Models` and `DataSources`.
+	*
+	* @class
+	*/
+	function Registry() {
+		this.defaultDataSources = {};
+		this.modelBuilder = new ModelBuilder();
+		require_lib_model(this);
+		require_lib_persisted_model(this);
+		this.modelBuilder.defaultModelBaseClass = this.getModel("Model");
+	}
+	/**
+	* Create a named vanilla JavaScript class constructor with an attached
+	* set of properties and options.
+	*
+	* This function comes with two variants:
+	*  * `loopback.createModel(name, properties, options)`
+	*  * `loopback.createModel(config)`
+	*
+	* In the second variant, the parameters `name`, `properties` and `options`
+	* are provided in the config object. Any additional config entries are
+	* interpreted as `options`, i.e. the following two configs are identical:
+	*
+	* ```js
+	* { name: 'Customer', base: 'User' }
+	* { name: 'Customer', options: { base: 'User' } }
+	* ```
+	*
+	* **Example**
+	*
+	* Create an `Author` model using the three-parameter variant:
+	*
+	* ```js
+	* loopback.createModel(
+	*   'Author',
+	*   {
+	*     firstName: 'string',
+	*     lastName: 'string'
+	*   },
+	*   {
+	*     relations: {
+	*       books: {
+	*         model: 'Book',
+	*         type: 'hasAndBelongsToMany'
+	*       }
+	*     }
+	*   }
+	* );
+	* ```
+	*
+	* Create the same model using a config object:
+	*
+	* ```js
+	* loopback.createModel({
+	*   name: 'Author',
+	*   properties: {
+	*     firstName: 'string',
+	*     lastName: 'string'
+	*   },
+	*   relations: {
+	*     books: {
+	*       model: 'Book',
+	*       type: 'hasAndBelongsToMany'
+	*     }
+	*   }
+	* });
+	* ```
+	*
+	* @param {String} name Unique name.
+	* @param {Object} properties
+	* @param {Object} options (optional)
+	*
+	* @header loopback.createModel
+	*/
+	Registry.prototype.createModel = function(name, properties, options) {
+		if (arguments.length === 1 && typeof name === "object") {
+			const config = name;
+			name = config.name;
+			properties = config.properties;
+			options = buildModelOptionsFromConfig(config);
+			assert(typeof name === "string", "The model-config property `name` must be a string");
+		}
+		options = options || {};
+		let BaseModel = options.base || options.super;
+		if (typeof BaseModel === "string") {
+			const baseName = BaseModel;
+			BaseModel = this.findModel(BaseModel);
+			if (!BaseModel) throw new Error(g.f("Model not found: model `%s` is extending an unknown model `%s`.", name, baseName));
+		}
+		BaseModel = BaseModel || this.getModel("PersistedModel");
+		const model = BaseModel.extend(name, properties, options);
+		model.registry = this;
+		this._defineRemoteMethods(model, model.settings.methods);
+		return model;
+	};
+	function buildModelOptionsFromConfig(config) {
+		const options = Object.assign({}, config.options);
+		for (const key in config) {
+			if ([
+				"name",
+				"properties",
+				"options"
+			].indexOf(key) !== -1) continue;
+			if (options[key] !== void 0) continue;
+			options[key] = config[key];
+		}
+		return options;
+	}
+	function addACL(acls, acl) {
+		for (let i = 0, n = acls.length; i < n; i++) if (acls[i].property === acl.property && acls[i].accessType === acl.accessType && acls[i].principalType === acl.principalType && acls[i].principalId === acl.principalId) {
+			acls[i] = acl;
+			return;
+		}
+		acls.push(acl);
+	}
+	/**
+	* Alter an existing Model class.
+	* @param {Model} ModelCtor The model constructor to alter.
+	* @options {Object} config Additional configuration to apply
+	* @property {DataSource} dataSource Attach the model to a dataSource.
+	* @property {Object} [relations] Model relations to add/update.
+	*
+	* @header loopback.configureModel(ModelCtor, config)
+	*/
+	Registry.prototype.configureModel = function(ModelCtor, config) {
+		const settings = ModelCtor.settings;
+		const modelName = ModelCtor.modelName;
+		ModelCtor.config = config;
+		if (typeof config.relations === "object" && config.relations !== null) {
+			const relations = settings.relations = settings.relations || {};
+			Object.keys(config.relations).forEach(function(key) {
+				relations[key] = Object.assign(relations[key] || {}, config.relations[key]);
+			});
+		} else if (config.relations != null) g.warn("The relations property of `%s` configuration must be an object", modelName);
+		if (Array.isArray(config.acls)) {
+			const acls = settings.acls = settings.acls || [];
+			config.acls.forEach(function(acl) {
+				addACL(acls, acl);
+			});
+		} else if (config.acls != null) g.warn("The acls property of `%s` configuration must be an array of objects", modelName);
+		const excludedProperties = {
+			base: true,
+			super: true,
+			relations: true,
+			acls: true,
+			dataSource: true
+		};
+		if (typeof config.options === "object" && config.options !== null) for (const p in config.options) if (!(p in excludedProperties)) settings[p] = config.options[p];
+		else g.warn("Property `%s` cannot be reconfigured for `%s`", p, modelName);
+		else if (config.options != null) g.warn("The options property of `%s` configuration must be an object", modelName);
+		if (config.dataSource) {
+			assert(config.dataSource instanceof DataSource, "Cannot configure " + ModelCtor.modelName + ": config.dataSource must be an instance of DataSource");
+			ModelCtor.attachTo(config.dataSource);
+			debug("Attached model `%s` to dataSource `%s`", modelName, config.dataSource.name);
+		} else if (config.dataSource === null || config.dataSource === false) debug("Model `%s` is not attached to any DataSource by configuration.", modelName);
+		else {
+			debug("Model `%s` is not attached to any DataSource, possibly by a mistake.", modelName);
+			g.warn("The configuration of `%s` is missing {{`dataSource`}} property.\nUse `null` or `false` to mark models not attached to any data source.", modelName);
+		}
+		const newMethodNames = config.methods && Object.keys(config.methods);
+		const hasNewMethods = newMethodNames && newMethodNames.length;
+		const hasDescendants = this.getModelByType(ModelCtor) !== ModelCtor;
+		if (hasNewMethods && hasDescendants) g.warn("Child models of `%s` will not inherit newly defined remote methods %s.", modelName, newMethodNames);
+		this._defineRemoteMethods(ModelCtor, config.methods);
+	};
+	Registry.prototype._defineRemoteMethods = function(ModelCtor, methods) {
+		if (!methods) return;
+		if (typeof methods !== "object") {
+			g.warn("Ignoring non-object \"methods\" setting of \"%s\".", ModelCtor.modelName);
+			return;
+		}
+		Object.keys(methods).forEach(function(key) {
+			let meta = methods[key];
+			const m = key.match(/^prototype\.(.*)$/);
+			const isStatic = !m;
+			if (typeof meta.isStatic !== "boolean") {
+				key = isStatic ? key : m[1];
+				meta = Object.assign({}, meta, { isStatic });
+			} else if (meta.isStatic && m) throw new Error(g.f("Remoting metadata for %s.%s {{\"isStatic\"}} does not match new method name-based style.", ModelCtor.modelName, key));
+			else {
+				key = isStatic ? key : m[1];
+				if (!meta.isStatic && isStatic) deprecated(g.f("Remoting metadata {{\"isStatic\"}} is deprecated. Please specify {{\"prototype.name\"}} in method name instead for {{isStatic=false}}."));
+			}
+			ModelCtor.remoteMethod(key, meta);
+		});
+	};
+	/**
+	* Look up a model class by name from all models created by
+	* `loopback.createModel()`
+	* @param {String|Function} modelOrName The model name or a `Model` constructor.
+	* @returns {Model} The model class
+	*
+	* @header loopback.findModel(modelName)
+	*/
+	Registry.prototype.findModel = function(modelName) {
+		if (typeof modelName === "function") return modelName;
+		return this.modelBuilder.models[modelName];
+	};
+	/**
+	* Look up a model class by name from all models created by
+	* `loopback.createModel()`. **Throw an error when no such model exists.**
+	*
+	* @param {String} modelOrName The model name or a `Model` constructor.
+	* @returns {Model} The model class
+	*
+	* @header loopback.getModel(modelName)
+	*/
+	Registry.prototype.getModel = function(modelName) {
+		const model = this.findModel(modelName);
+		if (model) return model;
+		throw new Error(g.f("Model not found: %s", modelName));
+	};
+	/**
+	* Look up a model class by the base model class.
+	* The method can be used by LoopBack
+	* to find configured models in models.json over the base model.
+	* @param {Model} modelType The base model class
+	* @returns {Model} The subclass if found or the base class
+	*
+	* @header loopback.getModelByType(modelType)
+	*/
+	Registry.prototype.getModelByType = function(modelType) {
+		const type = typeof modelType;
+		assert(["function", "string"].indexOf(type) > -1, "The model type must be a constructor or model name");
+		if (type === "string") modelType = this.getModel(modelType);
+		const models = this.modelBuilder.models;
+		for (const m in models) if (models[m].prototype instanceof modelType) return models[m];
+		return modelType;
+	};
+	/**
+	* Create a data source with passing the provided options to the connector.
+	*
+	* @param {String} name Optional name.
+	* @options {Object} options Data Source options
+	* @property {Object} connector LoopBack connector.
+	* @property {*} [*] Other&nbsp;connector properties.
+	*   See the relevant connector documentation.
+	*/
+	Registry.prototype.createDataSource = function(name, options) {
+		const self = this;
+		const ds = new DataSource(name, options, self.modelBuilder);
+		ds.createModel = function(name, properties, settings) {
+			settings = settings || {};
+			let BaseModel = settings.base || settings.super;
+			if (!BaseModel) {
+				const connectorTypes = ds.getTypes();
+				if (Array.isArray(connectorTypes) && connectorTypes.indexOf("db") !== -1) BaseModel = self.PersistedModel;
+				else BaseModel = self.Model;
+				settings.base = BaseModel;
+			}
+			const ModelCtor = self.createModel(name, properties, settings);
+			ModelCtor.attachTo(ds);
+			return ModelCtor;
+		};
+		if (ds.settings && ds.settings.defaultForType) {
+			const msg = g.f("{{DataSource}} option {{\"defaultForType\"}} is no longer supported");
+			throw new Error(msg);
+		}
+		return ds;
+	};
+	/**
+	* Get an in-memory data source. Use one if it already exists.
+	*
+	* @param {String} [name] The name of the data source.
+	* If not provided, the `'default'` is used.
+	*/
+	Registry.prototype.memory = function(name) {
+		name = name || "default";
+		let memory = (this._memoryDataSources || (this._memoryDataSources = {}))[name];
+		if (!memory) memory = this._memoryDataSources[name] = this.createDataSource({ connector: "memory" });
+		return memory;
+	};
+}));
+//#endregion
+module.exports = require_registry();

package/dist/lib/runtime.cjs

@@ -0,0 +1,25 @@
+//#region src/lib/runtime.ts
+var require_runtime = /* @__PURE__ */ require("../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports, module) => {
+	/**
+	* True if running in a browser environment; false otherwise.
+	* @header loopback.isBrowser
+	*/
+	const isBrowser = typeof window !== "undefined";
+	/**
+	* True if running in a server environment; false otherwise.
+	* @header loopback.isServer
+	*/
+	const runtime = {
+		isBrowser,
+		isServer: !isBrowser
+	};
+	Object.defineProperty(runtime, "loopback", {
+		value: null,
+		writable: true,
+		configurable: true,
+		enumerable: false
+	});
+	module.exports = runtime;
+}));
+//#endregion
+module.exports = require_runtime();

package/dist/lib/server-app.cjs

@@ -0,0 +1,231 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_lib_globalize = require("./globalize.cjs");
+//#region src/lib/server-app.ts
+var require_server_app = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const g = require_lib_globalize;
+	const assert = require("assert");
+	const express = require("express");
+	const mergePhaseNameLists = require("@vsaas/remoting/phases").mergePhaseNameLists;
+	const debug = require("debug")("loopback:app");
+	const BUILTIN_MIDDLEWARE = { builtin: true };
+	const proto = {};
+	function loopbackExpress() {
+		const app = express();
+		app.__expressLazyRouter = app.lazyrouter;
+		Object.assign(app, proto);
+		return app;
+	}
+	/**
+	* Register a middleware using a factory function and a JSON config.
+	*
+	* **Example**
+	*
+	* ```js
+	* app.middlewareFromConfig(compression, {
+	*   enabled: true,
+	*   phase: 'initial',
+	*   params: {
+	*     threshold: 128
+	*   }
+	* });
+	* ```
+	*
+	* @param {function} factory The factory function creating a middleware handler.
+	*   Typically a result of `require()` call, e.g. `require('compression')`.
+	* @options {Object} config The configuration.
+	* @property {String} phase The phase to register the middleware in.
+	* @property {Boolean} [enabled] Whether the middleware is enabled.
+	*   Default: `true`.
+	* @property {Array|*} [params] The arguments to pass to the factory
+	*   function. Either an array of arguments,
+	*   or the value of the first argument when the factory expects
+	*   a single argument only.
+	* @property {Array|string|RegExp} [paths] Optional list of paths limiting
+	*   the scope of the middleware.
+	*
+	* @returns {object} this (fluent API)
+	*
+	* @header app.middlewareFromConfig(factory, config)
+	*/
+	proto.middlewareFromConfig = function(factory, config) {
+		assert(typeof factory === "function", "\"factory\" must be a function");
+		assert(typeof config === "object", "\"config\" must be an object");
+		assert(typeof config.phase === "string" && config.phase, "\"config.phase\" must be a non-empty string");
+		if (config.enabled === false) return;
+		let params = config.params;
+		if (params === void 0) params = [];
+		else if (!Array.isArray(params)) params = [params];
+		let handler = factory.apply(null, params);
+		let verbs = config.methods || config.verbs;
+		if (Array.isArray(verbs)) {
+			verbs = verbs.map(function(verb) {
+				return verb && verb.toUpperCase();
+			});
+			if (verbs.indexOf("ALL") === -1) {
+				const originalHandler = handler;
+				if (handler.length <= 3) handler = function(req, res, next) {
+					if (verbs.indexOf(req.method.toUpperCase()) === -1) return next();
+					originalHandler(req, res, next);
+				};
+				else handler = function(err, req, res, next) {
+					if (verbs.indexOf(req.method.toUpperCase()) === -1) return next(err);
+					originalHandler(err, req, res, next);
+				};
+			}
+		}
+		this.middleware(config.phase, config.paths || [], handler);
+		return this;
+	};
+	/**
+	* Register (new) middleware phases.
+	*
+	* If all names are new, then the phases are added just before "routes" phase.
+	* Otherwise the provided list of names is merged with the existing phases
+	* in such way that the order of phases is preserved.
+	*
+	* **Examples**
+	*
+	* ```js
+	* // built-in phases:
+	* // initial, session, auth, parse, routes, files, final
+	*
+	* app.defineMiddlewarePhases('custom');
+	* // new list of phases
+	* // initial, session, auth, parse, custom, routes, files, final
+	*
+	* app.defineMiddlewarePhases([
+	*   'initial', 'postinit', 'preauth', 'routes', 'subapps'
+	* ]);
+	* // new list of phases
+	* // initial, postinit, preauth, session, auth, parse, custom,
+	* // routes, subapps, files, final
+	* ```
+	*
+	* @param {string|Array.<string>} nameOrArray A phase name or a list of phase
+	*   names to add.
+	*
+	* @returns {object} this (fluent API)
+	*
+	* @header app.defineMiddlewarePhases(nameOrArray)
+	*/
+	proto.defineMiddlewarePhases = function(nameOrArray) {
+		this.lazyrouter();
+		if (Array.isArray(nameOrArray)) this._requestHandlingPhases = mergePhaseNameLists(this._requestHandlingPhases, nameOrArray);
+		else {
+			const routesIx = this._requestHandlingPhases.indexOf("routes");
+			this._requestHandlingPhases.splice(routesIx - 1, 0, nameOrArray);
+		}
+		return this;
+	};
+	/**
+	* Register a middleware handler to be executed in a given phase.
+	* @param {string} name The phase name, e.g. "init" or "routes".
+	* @param {Array|string|RegExp} [paths] Optional list of paths limiting
+	*   the scope of the middleware.
+	*   String paths are interpreted as expressjs path patterns,
+	*   regular expressions are used as-is.
+	* @param {function} handler The middleware handler, one of
+	*   `function(req, res, next)` or
+	*   `function(err, req, res, next)`
+	* @returns {object} this (fluent API)
+	*
+	* @header app.middleware(name, handler)
+	*/
+	proto.middleware = function(name, paths, handler) {
+		this.lazyrouter();
+		if (handler === void 0 && typeof paths === "function") {
+			handler = paths;
+			paths = void 0;
+		}
+		assert(typeof name === "string" && name, "\"name\" must be a non-empty string");
+		assert(typeof handler === "function", "\"handler\" must be a function");
+		if (paths === void 0) paths = "/";
+		const fullPhaseName = name;
+		const handlerName = handler.name || "<anonymous>";
+		const m = name.match(/^(.+):(before|after)$/);
+		if (m) name = m[1];
+		if (this._requestHandlingPhases.indexOf(name) === -1) throw new Error(g.f("Unknown {{middleware}} phase %s", name));
+		debug("use %s %s %s", fullPhaseName, paths, handlerName);
+		this._skipLayerSorting = true;
+		this.use(paths, handler);
+		const layer = this._findLayerByHandler(handler);
+		if (layer) layer.phase = fullPhaseName;
+		else debug("No matching layer is found for %s %s", fullPhaseName, handlerName);
+		this._skipLayerSorting = false;
+		this._sortLayersByPhase();
+		return this;
+	};
+	/*!
+	* Find the corresponding express layer by handler
+	*
+	* This is needed because monitoring agents such as NewRelic can add handlers
+	* to the stack. For example, NewRelic adds sentinel handler. We need to search
+	* the stackto find the correct layer.
+	*/
+	proto._findLayerByHandler = function(handler) {
+		for (let k = this._router.stack.length - 1; k >= 0; k--) {
+			const isOriginal = this._router.stack[k].handle === handler;
+			const isNewRelic = this._router.stack[k].handle["__NR_original"] === handler;
+			const isAppDynamics = this._router.stack[k].handle["__appdynamicsProxyInfo__"] && this._router.stack[k].handle["__appdynamicsProxyInfo__"]["orig"] === handler;
+			if (isOriginal || isNewRelic || isAppDynamics) return this._router.stack[k];
+			else for (const p in this._router.stack[k].handle) if (this._router.stack[k].handle[p] === handler) return this._router.stack[k];
+		}
+		return null;
+	};
+	proto.lazyrouter = function() {
+		const self = this;
+		if (self._router) return;
+		self.__expressLazyRouter();
+		const router = self._router;
+		router.stack.forEach(function(layer) {
+			layer.phase = BUILTIN_MIDDLEWARE;
+		});
+		router.__expressUse = router.use;
+		router.use = function useAndSort() {
+			const retval = this.__expressUse.apply(this, arguments);
+			self._sortLayersByPhase();
+			return retval;
+		};
+		router.__expressRoute = router.route;
+		router.route = function routeAndSort() {
+			const retval = this.__expressRoute.apply(this, arguments);
+			self._sortLayersByPhase();
+			return retval;
+		};
+		self._requestHandlingPhases = [
+			"initial",
+			"session",
+			"auth",
+			"parse",
+			"routes",
+			"files",
+			"final"
+		];
+	};
+	proto._sortLayersByPhase = function() {
+		if (this._skipLayerSorting) return;
+		const phaseOrder = {};
+		this._requestHandlingPhases.forEach(function(name, ix) {
+			phaseOrder[name + ":before"] = ix * 3;
+			phaseOrder[name] = ix * 3 + 1;
+			phaseOrder[name + ":after"] = ix * 3 + 2;
+		});
+		this._router.stack.sort(compareLayers);
+		function compareLayers(left, right) {
+			const leftPhase = left.phase;
+			const rightPhase = right.phase;
+			if (leftPhase === rightPhase) return 0;
+			if (leftPhase === BUILTIN_MIDDLEWARE) return -1;
+			if (rightPhase === BUILTIN_MIDDLEWARE) return 1;
+			if (leftPhase === void 0) {
+				if (rightPhase === "routes") return -1;
+				return phaseOrder.routes - phaseOrder[rightPhase];
+			}
+			if (rightPhase === void 0) return -compareLayers(right, left);
+			return phaseOrder[leftPhase] - phaseOrder[rightPhase];
+		}
+	};
+	module.exports = loopbackExpress;
+}));
+//#endregion
+module.exports = require_server_app();

package/dist/lib/utils.cjs

@@ -0,0 +1,154 @@
+//#region src/lib/utils.ts
+var require_utils = /* @__PURE__ */ require("../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports, module) => {
+	const hasOwnProperty = Object.prototype.hasOwnProperty;
+	function createPromiseCallback() {
+		let cb;
+		const promise = new Promise(function(resolve, reject) {
+			cb = function(err, data) {
+				if (err) return reject(err);
+				return resolve(data);
+			};
+		});
+		cb.promise = promise;
+		return cb;
+	}
+	function asCallback(promise, cb) {
+		if (typeof cb !== "function") return promise;
+		promise.then(function(result) {
+			cb(null, result);
+		}, function(err) {
+			cb(err);
+		});
+		return cb;
+	}
+	function invokeWithCallback(fn, receiver, args) {
+		return new Promise(function(resolve, reject) {
+			const argCount = args ? args.length : 0;
+			const invokeArgs = new Array(argCount + 1);
+			for (let i = 0; i < argCount; i++) invokeArgs[i] = args[i];
+			invokeArgs[argCount] = function(err, value) {
+				if (err) return reject(err);
+				resolve(value);
+			};
+			fn.apply(receiver, invokeArgs);
+		});
+	}
+	/**
+	* Divide an async call with large array into multiple calls using smaller chunks
+	* @param {Array} largeArray - the large array to be chunked
+	* @param {Number} chunkSize - size of each chunks
+	* @param {Function} processFunction - the function to be called multiple times
+	* @param {Function} cb - the callback
+	*/
+	function uploadInChunks(largeArray, chunkSize, processFunction, cb) {
+		cb = cb || createPromiseCallback();
+		(async function() {
+			if (!chunkSize || chunkSize < 1 || largeArray.length <= chunkSize) return invokeWithCallback(processFunction, null, [largeArray]);
+			let previousResults;
+			for (let start = 0; start < largeArray.length; start += chunkSize) {
+				const results = await invokeWithCallback(processFunction, null, [largeArray.slice(start, start + chunkSize)]);
+				previousResults = mergeChunkResults(previousResults, results);
+			}
+			return previousResults;
+		})().then(function(results) {
+			cb(null, results);
+		}, function(err) {
+			cb(err);
+		});
+		return cb.promise;
+	}
+	/**
+	* Page async download calls
+	* @param {Object} filter - filter object used for the async call
+	* @param {Number} chunkSize - size of each chunks
+	* @param {Function} processFunction - the function to be called multiple times
+	* @param {Function} cb - the callback
+	*/
+	function downloadInChunks(filter, chunkSize, processFunction, cb) {
+		cb = cb || createPromiseCallback();
+		const baseFilter = filter ? cloneFilter(filter) : {};
+		(async function() {
+			if (!chunkSize || chunkSize < 1) return invokeWithCallback(processFunction, null, [baseFilter]);
+			let results;
+			let skip = 0;
+			while (true) {
+				const currentFilter = cloneFilter(baseFilter);
+				currentFilter.skip = skip;
+				currentFilter.limit = chunkSize;
+				const pagedResults = await invokeWithCallback(processFunction, null, [currentFilter]);
+				results = mergeChunkResults(results, pagedResults);
+				const pagedResultCount = pagedResults && typeof pagedResults.length === "number" ? pagedResults.length : 0;
+				if (pagedResultCount < chunkSize) return results;
+				skip += pagedResultCount;
+			}
+		})().then(function(results) {
+			cb(null, results);
+		}, function(err) {
+			cb(err);
+		});
+		return cb.promise;
+	}
+	/**
+	* Concat current results into previous results
+	* Assumption made here that the previous results and current results are homogeneous
+	* @param {Object|Array} previousResults
+	* @param {Object|Array} currentResults
+	*/
+	function concatResults(previousResults, currentResults) {
+		if (Array.isArray(currentResults)) previousResults = concatArrays(previousResults, currentResults);
+		else if (typeof currentResults === "object") {
+			for (const key in currentResults) if (hasOwnProperty.call(currentResults, key)) previousResults[key] = concatResults(previousResults[key], currentResults[key]);
+		} else previousResults = currentResults;
+		return previousResults;
+	}
+	function mergeChunkResults(previousResults, currentResults) {
+		if (typeof previousResults === "undefined" || previousResults === null) return cloneChunkResult(currentResults);
+		if (typeof currentResults === "undefined" || currentResults === null) return previousResults;
+		if (Array.isArray(previousResults) && Array.isArray(currentResults)) {
+			appendArrayItems(previousResults, currentResults);
+			return previousResults;
+		}
+		if (isPlainObject(previousResults) && isPlainObject(currentResults)) {
+			for (const key in currentResults) if (hasOwnProperty.call(currentResults, key)) previousResults[key] = mergeChunkResults(previousResults[key], currentResults[key]);
+			return previousResults;
+		}
+		return currentResults;
+	}
+	function cloneChunkResult(value) {
+		if (Array.isArray(value)) return value.slice();
+		if (isPlainObject(value)) {
+			const clone = {};
+			for (const key in value) if (hasOwnProperty.call(value, key)) clone[key] = cloneChunkResult(value[key]);
+			return clone;
+		}
+		return value;
+	}
+	function appendArrayItems(target, items) {
+		for (let i = 0; i < items.length; i++) target.push(items[i]);
+	}
+	function concatArrays(left, right) {
+		const result = new Array(left.length + right.length);
+		let index = 0;
+		for (let i = 0; i < left.length; i++) result[index++] = left[i];
+		for (let i = 0; i < right.length; i++) result[index++] = right[i];
+		return result;
+	}
+	function isPlainObject(value) {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+		const prototype = Object.getPrototypeOf(value);
+		return prototype === Object.prototype || prototype === null;
+	}
+	function cloneFilter(filter) {
+		return JSON.parse(JSON.stringify(filter));
+	}
+	module.exports = {
+		asCallback,
+		concatResults,
+		createPromiseCallback,
+		downloadInChunks,
+		invokeWithCallback,
+		uploadInChunks
+	};
+}));
+//#endregion
+module.exports = require_utils();