@autofleet/sadot 1.6.16 → 1.6.18-beta.0

package/dist/_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.mjs

@@ -0,0 +1,10 @@
+//#region \0@oxc-project+runtime@0.103.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+export { __decorate };

package/dist/_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.mjs

@@ -0,0 +1,7 @@
+//#region \0@oxc-project+runtime@0.103.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+//#endregion
+export { __decorateMetadata };

package/dist/_virtual/rolldown_runtime.mjs

@@ -0,0 +1,22 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __commonJSMin, __export, __require };

package/dist/index.d.mts

@@ -0,0 +1,26 @@
+import { CUSTOM_FIELDS_FILTER_SCOPE, CustomFieldDefinitionType, supportedEntities } from "./packages/sadot/src/utils/constants/index.mjs";
+import { CustomFieldValue } from "./packages/sadot/src/models/CustomFieldValue.mjs";
+import { CustomFieldDefinition } from "./packages/sadot/src/models/CustomFieldDefinition.mjs";
+import { CustomValidator } from "./packages/sadot/src/models/CustomValidator.mjs";
+import { CustomFieldOptions, ModelFetcher, Models } from "./packages/sadot/src/types/index.mjs";
+import { SadotInitializationState } from "./packages/sadot/src/init-state.mjs";
+import { CustomFieldsSchema } from "./packages/sadot/src/utils/validations/schema/custom-fields.mjs";
+import { generateCustomFieldSearchQueryPayload, generateRandomString } from "./packages/sadot/src/utils/helpers/index.mjs";
+import { customFieldsSortScope } from "./packages/sadot/src/scopes/filter.mjs";
+import { CustomFieldEntries } from "./packages/sadot/src/models/CustomFieldEntries.mjs";
+import "./packages/sadot/src/models/index.mjs";
+import { FieldPolicy, ModelInclusion, ModelMode } from "./packages/sadot/src/models/FieldPolicy.mjs";
+import { field_policy_d_exports } from "./packages/sadot/src/repository/field-policy.mjs";
+import { Sequelize } from "sequelize-typescript";
+import { Application } from "express";
+
+//#region src/index.d.ts
+declare const sadotInitState: SadotInitializationState;
+/**
+* Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
+* @see {@link 'custom-fields/config'} for configurations
+*/
+declare const useCustomFields: (app: Pick<Application, "use"> | null, getModel: ModelFetcher, options: CustomFieldOptions) => Promise<Sequelize>;
+declare const disableCustomFields: (models: Models[], getModel: ModelFetcher) => void;
+//#endregion
+export { CUSTOM_FIELDS_FILTER_SCOPE, CustomFieldDefinition, CustomFieldDefinitionType, CustomFieldEntries, CustomFieldValue, CustomFieldsSchema, CustomValidator, FieldPolicy, field_policy_d_exports as FieldPolicyRepo, type ModelInclusion, type ModelMode, customFieldsSortScope, useCustomFields as default, disableCustomFields, generateCustomFieldSearchQueryPayload, generateRandomString, sadotInitState, supportedEntities };

package/dist/index.mjs

@@ -0,0 +1,66 @@
+import logger_default, { tryAddingTraceIdMiddleware } from "./packages/sadot/src/utils/logger/index.mjs";
+import { CUSTOM_FIELDS_FILTER_SCOPE, CustomFieldDefinitionType, supportedEntities } from "./packages/sadot/src/utils/constants/index.mjs";
+import CustomFieldValue_default from "./packages/sadot/src/models/CustomFieldValue.mjs";
+import CustomFieldDefinition_default from "./packages/sadot/src/models/CustomFieldDefinition.mjs";
+import CustomFieldEntries_default from "./packages/sadot/src/models/CustomFieldEntries.mjs";
+import CustomValidator_default from "./packages/sadot/src/models/CustomValidator.mjs";
+import { runSadotMigrations } from "./packages/sadot/src/migrations/index.mjs";
+import { initTables, initTestModels } from "./packages/sadot/src/models/index.mjs";
+import { matPathState } from "./packages/sadot/src/mat-path-state.mjs";
+import FieldPolicy_default from "./packages/sadot/src/models/FieldPolicy.mjs";
+import { field_policy_exports } from "./packages/sadot/src/repository/field-policy.mjs";
+import templates_default from "./packages/sadot/src/api/v1/templates/index.mjs";
+import api_default from "./packages/sadot/src/api/index.mjs";
+import db_default from "./packages/sadot/src/utils/db/index.mjs";
+import { generateCustomFieldSearchQueryPayload, generateRandomString } from "./packages/sadot/src/utils/helpers/index.mjs";
+import { customFieldsSortScope } from "./packages/sadot/src/scopes/filter.mjs";
+import { addHooks, addScopes, applyCustomAssociation, removeHooks } from "./packages/sadot/src/utils/init.mjs";
+import { SadotInitializationState } from "./packages/sadot/src/init-state.mjs";
+import { CustomFieldsSchema } from "./packages/sadot/src/utils/validations/schema/custom-fields.mjs";
+
+//#region src/index.ts
+const sadotInitState = new SadotInitializationState();
+/**
+* Internal implementation of custom fields initialization
+* Contains all the business logic without state tracking
+*/
+const internalUseCustomFields = async (app, getModel, options) => {
+	tryAddingTraceIdMiddleware();
+	const { models, useCustomFieldsEntries, useModelTypeMapping, isMatPathEnabled, runLegacyMigrations } = options;
+	matPathState.isMatPathEnabled = isMatPathEnabled;
+	if (app) {
+		app.use("/api", api_default);
+		app.use("/api/v1/templates", templates_default);
+	}
+	const sequelize = options.sequelize ?? db_default(options.databaseConfig);
+	if (process.env.NODE_ENV === "test") await initTestModels(sequelize);
+	sequelize.addModels([FieldPolicy_default]);
+	addHooks(models, getModel, { useCustomFieldsEntries });
+	await initTables(sequelize, options.getUser, {
+		useCustomFieldsEntries,
+		useModelTypeMapping,
+		isMatPathEnabled,
+		runLegacyMigrations
+	});
+	await runSadotMigrations(sequelize);
+	addScopes(models, getModel, { useCustomFieldsEntries });
+	applyCustomAssociation(models);
+	logger_default.debug("sadot - custom fields finished initializing with models", models);
+	return sequelize;
+};
+/**
+* Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
+* @see {@link 'custom-fields/config'} for configurations
+*/
+const useCustomFields = async (app, getModel, options) => {
+	const initPromise = internalUseCustomFields(app, getModel, options);
+	sadotInitState.setInitPromise(initPromise, !options.sequelize);
+	return await initPromise;
+};
+var src_default = useCustomFields;
+const disableCustomFields = (models, getModel) => {
+	removeHooks(models, getModel);
+};
+
+//#endregion
+export { CUSTOM_FIELDS_FILTER_SCOPE, CustomFieldDefinition_default as CustomFieldDefinition, CustomFieldDefinitionType, CustomFieldEntries_default as CustomFieldEntries, CustomFieldValue_default as CustomFieldValue, CustomFieldsSchema, CustomValidator_default as CustomValidator, FieldPolicy_default as FieldPolicy, field_policy_exports as FieldPolicyRepo, customFieldsSortScope, src_default as default, disableCustomFields, generateCustomFieldSearchQueryPayload, generateRandomString, sadotInitState, supportedEntities };

package/dist/node_modules/accepts/index.mjs

@@ -0,0 +1,175 @@
+import { __commonJSMin } from "../../_virtual/rolldown_runtime.mjs";
+import { require_mime_types } from "../mime-types/index.mjs";
+import { require_negotiator } from "../negotiator/index.mjs";
+
+//#region ../../node_modules/accepts/index.js
+/*!
+* accepts
+* Copyright(c) 2014 Jonathan Ong
+* Copyright(c) 2015 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_accepts = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var Negotiator = require_negotiator();
+	var mime = require_mime_types();
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = Accepts;
+	/**
+	* Create a new Accepts object for the given req.
+	*
+	* @param {object} req
+	* @public
+	*/
+	function Accepts(req) {
+		if (!(this instanceof Accepts)) return new Accepts(req);
+		this.headers = req.headers;
+		this.negotiator = new Negotiator(req);
+	}
+	/**
+	* Check if the given `type(s)` is acceptable, returning
+	* the best match when true, otherwise `undefined`, in which
+	* case you should respond with 406 "Not Acceptable".
+	*
+	* The `type` value may be a single mime type string
+	* such as "application/json", the extension name
+	* such as "json" or an array `["json", "html", "text/plain"]`. When a list
+	* or array is given the _best_ match, if any is returned.
+	*
+	* Examples:
+	*
+	*     // Accept: text/html
+	*     this.types('html');
+	*     // => "html"
+	*
+	*     // Accept: text/*, application/json
+	*     this.types('html');
+	*     // => "html"
+	*     this.types('text/html');
+	*     // => "text/html"
+	*     this.types('json', 'text');
+	*     // => "json"
+	*     this.types('application/json');
+	*     // => "application/json"
+	*
+	*     // Accept: text/*, application/json
+	*     this.types('image/png');
+	*     this.types('png');
+	*     // => undefined
+	*
+	*     // Accept: text/*;q=.5, application/json
+	*     this.types(['html', 'json']);
+	*     this.types('html', 'json');
+	*     // => "json"
+	*
+	* @param {String|Array} types...
+	* @return {String|Array|Boolean}
+	* @public
+	*/
+	Accepts.prototype.type = Accepts.prototype.types = function(types_) {
+		var types = types_;
+		if (types && !Array.isArray(types)) {
+			types = new Array(arguments.length);
+			for (var i = 0; i < types.length; i++) types[i] = arguments[i];
+		}
+		if (!types || types.length === 0) return this.negotiator.mediaTypes();
+		if (!this.headers.accept) return types[0];
+		var mimes = types.map(extToMime);
+		var first = this.negotiator.mediaTypes(mimes.filter(validMime))[0];
+		return first ? types[mimes.indexOf(first)] : false;
+	};
+	/**
+	* Return accepted encodings or best fit based on `encodings`.
+	*
+	* Given `Accept-Encoding: gzip, deflate`
+	* an array sorted by quality is returned:
+	*
+	*     ['gzip', 'deflate']
+	*
+	* @param {String|Array} encodings...
+	* @return {String|Array}
+	* @public
+	*/
+	Accepts.prototype.encoding = Accepts.prototype.encodings = function(encodings_) {
+		var encodings = encodings_;
+		if (encodings && !Array.isArray(encodings)) {
+			encodings = new Array(arguments.length);
+			for (var i = 0; i < encodings.length; i++) encodings[i] = arguments[i];
+		}
+		if (!encodings || encodings.length === 0) return this.negotiator.encodings();
+		return this.negotiator.encodings(encodings)[0] || false;
+	};
+	/**
+	* Return accepted charsets or best fit based on `charsets`.
+	*
+	* Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
+	* an array sorted by quality is returned:
+	*
+	*     ['utf-8', 'utf-7', 'iso-8859-1']
+	*
+	* @param {String|Array} charsets...
+	* @return {String|Array}
+	* @public
+	*/
+	Accepts.prototype.charset = Accepts.prototype.charsets = function(charsets_) {
+		var charsets = charsets_;
+		if (charsets && !Array.isArray(charsets)) {
+			charsets = new Array(arguments.length);
+			for (var i = 0; i < charsets.length; i++) charsets[i] = arguments[i];
+		}
+		if (!charsets || charsets.length === 0) return this.negotiator.charsets();
+		return this.negotiator.charsets(charsets)[0] || false;
+	};
+	/**
+	* Return accepted languages or best fit based on `langs`.
+	*
+	* Given `Accept-Language: en;q=0.8, es, pt`
+	* an array sorted by quality is returned:
+	*
+	*     ['es', 'pt', 'en']
+	*
+	* @param {String|Array} langs...
+	* @return {Array|String}
+	* @public
+	*/
+	Accepts.prototype.lang = Accepts.prototype.langs = Accepts.prototype.language = Accepts.prototype.languages = function(languages_) {
+		var languages = languages_;
+		if (languages && !Array.isArray(languages)) {
+			languages = new Array(arguments.length);
+			for (var i = 0; i < languages.length; i++) languages[i] = arguments[i];
+		}
+		if (!languages || languages.length === 0) return this.negotiator.languages();
+		return this.negotiator.languages(languages)[0] || false;
+	};
+	/**
+	* Convert extnames to mime.
+	*
+	* @param {String} type
+	* @return {String}
+	* @private
+	*/
+	function extToMime(type) {
+		return type.indexOf("/") === -1 ? mime.lookup(type) : type;
+	}
+	/**
+	* Check if mime is valid.
+	*
+	* @param {String} type
+	* @return {String}
+	* @private
+	*/
+	function validMime(type) {
+		return typeof type === "string";
+	}
+}));
+
+//#endregion
+export default require_accepts();
+
+export { require_accepts };

package/dist/node_modules/array-flatten/array-flatten.mjs

@@ -0,0 +1,56 @@
+import { __commonJSMin } from "../../_virtual/rolldown_runtime.mjs";
+
+//#region ../../node_modules/array-flatten/array-flatten.js
+var require_array_flatten = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Expose `arrayFlatten`.
+	*/
+	module.exports = arrayFlatten;
+	/**
+	* Recursive flatten function with depth.
+	*
+	* @param  {Array}  array
+	* @param  {Array}  result
+	* @param  {Number} depth
+	* @return {Array}
+	*/
+	function flattenWithDepth(array, result, depth) {
+		for (var i = 0; i < array.length; i++) {
+			var value = array[i];
+			if (depth > 0 && Array.isArray(value)) flattenWithDepth(value, result, depth - 1);
+			else result.push(value);
+		}
+		return result;
+	}
+	/**
+	* Recursive flatten function. Omitting depth is slightly faster.
+	*
+	* @param  {Array} array
+	* @param  {Array} result
+	* @return {Array}
+	*/
+	function flattenForever(array, result) {
+		for (var i = 0; i < array.length; i++) {
+			var value = array[i];
+			if (Array.isArray(value)) flattenForever(value, result);
+			else result.push(value);
+		}
+		return result;
+	}
+	/**
+	* Flatten an array, with the ability to define a depth.
+	*
+	* @param  {Array}  array
+	* @param  {Number} depth
+	* @return {Array}
+	*/
+	function arrayFlatten(array, depth) {
+		if (depth == null) return flattenForever(array, []);
+		return flattenWithDepth(array, [], depth);
+	}
+}));
+
+//#endregion
+export default require_array_flatten();
+
+export { require_array_flatten };

package/dist/node_modules/body-parser/index.mjs

@@ -0,0 +1,135 @@
+import { __commonJSMin } from "../../_virtual/rolldown_runtime.mjs";
+import { require_depd } from "../depd/index.mjs";
+import { require_json } from "./lib/types/json.mjs";
+import { require_raw } from "./lib/types/raw.mjs";
+import { require_text } from "./lib/types/text.mjs";
+import { require_urlencoded } from "./lib/types/urlencoded.mjs";
+
+//#region ../../node_modules/body-parser/index.js
+/*!
+* body-parser
+* Copyright(c) 2014-2015 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_body_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var deprecate = require_depd()("body-parser");
+	/**
+	* Cache of loaded parsers.
+	* @private
+	*/
+	var parsers = Object.create(null);
+	/**
+	* @typedef Parsers
+	* @type {function}
+	* @property {function} json
+	* @property {function} raw
+	* @property {function} text
+	* @property {function} urlencoded
+	*/
+	/**
+	* Module exports.
+	* @type {Parsers}
+	*/
+	exports = module.exports = deprecate.function(bodyParser, "bodyParser: use individual json/urlencoded middlewares");
+	/**
+	* JSON parser.
+	* @public
+	*/
+	Object.defineProperty(exports, "json", {
+		configurable: true,
+		enumerable: true,
+		get: createParserGetter("json")
+	});
+	/**
+	* Raw parser.
+	* @public
+	*/
+	Object.defineProperty(exports, "raw", {
+		configurable: true,
+		enumerable: true,
+		get: createParserGetter("raw")
+	});
+	/**
+	* Text parser.
+	* @public
+	*/
+	Object.defineProperty(exports, "text", {
+		configurable: true,
+		enumerable: true,
+		get: createParserGetter("text")
+	});
+	/**
+	* URL-encoded parser.
+	* @public
+	*/
+	Object.defineProperty(exports, "urlencoded", {
+		configurable: true,
+		enumerable: true,
+		get: createParserGetter("urlencoded")
+	});
+	/**
+	* Create a middleware to parse json and urlencoded bodies.
+	*
+	* @param {object} [options]
+	* @return {function}
+	* @deprecated
+	* @public
+	*/
+	function bodyParser(options) {
+		var opts = Object.create(options || null, { type: {
+			configurable: true,
+			enumerable: true,
+			value: void 0,
+			writable: true
+		} });
+		var _urlencoded = exports.urlencoded(opts);
+		var _json = exports.json(opts);
+		return function bodyParser(req, res, next) {
+			_json(req, res, function(err) {
+				if (err) return next(err);
+				_urlencoded(req, res, next);
+			});
+		};
+	}
+	/**
+	* Create a getter for loading a parser.
+	* @private
+	*/
+	function createParserGetter(name) {
+		return function get() {
+			return loadParser(name);
+		};
+	}
+	/**
+	* Load a parser module.
+	* @private
+	*/
+	function loadParser(parserName) {
+		var parser = parsers[parserName];
+		if (parser !== void 0) return parser;
+		switch (parserName) {
+			case "json":
+				parser = require_json();
+				break;
+			case "raw":
+				parser = require_raw();
+				break;
+			case "text":
+				parser = require_text();
+				break;
+			case "urlencoded":
+				parser = require_urlencoded();
+				break;
+		}
+		return parsers[parserName] = parser;
+	}
+}));
+
+//#endregion
+export default require_body_parser();
+
+export { require_body_parser };

package/dist/node_modules/body-parser/lib/read.mjs

@@ -0,0 +1,164 @@
+import { __commonJSMin, __require } from "../../../_virtual/rolldown_runtime.mjs";
+import { require_http_errors } from "../../http-errors/index.mjs";
+import { require_destroy } from "../../destroy/index.mjs";
+import { require_lib } from "../../iconv-lite/lib/index.mjs";
+import { require_unpipe } from "../../unpipe/index.mjs";
+import { require_raw_body } from "../../raw-body/index.mjs";
+import { require_on_finished } from "../../on-finished/index.mjs";
+
+//#region ../../node_modules/body-parser/lib/read.js
+/*!
+* body-parser
+* Copyright(c) 2014-2015 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_read = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var createError = require_http_errors();
+	var destroy = require_destroy();
+	var getBody = require_raw_body();
+	var iconv = require_lib();
+	var onFinished = require_on_finished();
+	var unpipe = require_unpipe();
+	var zlib = __require("zlib");
+	/**
+	* Module exports.
+	*/
+	module.exports = read;
+	/**
+	* Read a request into a buffer and parse.
+	*
+	* @param {object} req
+	* @param {object} res
+	* @param {function} next
+	* @param {function} parse
+	* @param {function} debug
+	* @param {object} options
+	* @private
+	*/
+	function read(req, res, next, parse, debug, options) {
+		var length;
+		var opts = options;
+		var stream;
+		req._body = true;
+		var encoding = opts.encoding !== null ? opts.encoding : null;
+		var verify = opts.verify;
+		try {
+			stream = contentstream(req, debug, opts.inflate);
+			length = stream.length;
+			stream.length = void 0;
+		} catch (err) {
+			return next(err);
+		}
+		opts.length = length;
+		opts.encoding = verify ? null : encoding;
+		if (opts.encoding === null && encoding !== null && !iconv.encodingExists(encoding)) return next(createError(415, "unsupported charset \"" + encoding.toUpperCase() + "\"", {
+			charset: encoding.toLowerCase(),
+			type: "charset.unsupported"
+		}));
+		debug("read body");
+		getBody(stream, opts, function(error, body) {
+			if (error) {
+				var _error;
+				if (error.type === "encoding.unsupported") _error = createError(415, "unsupported charset \"" + encoding.toUpperCase() + "\"", {
+					charset: encoding.toLowerCase(),
+					type: "charset.unsupported"
+				});
+				else _error = createError(400, error);
+				if (stream !== req) {
+					unpipe(req);
+					destroy(stream, true);
+				}
+				dump(req, function onfinished() {
+					next(createError(400, _error));
+				});
+				return;
+			}
+			if (verify) try {
+				debug("verify body");
+				verify(req, res, body, encoding);
+			} catch (err) {
+				next(createError(403, err, {
+					body,
+					type: err.type || "entity.verify.failed"
+				}));
+				return;
+			}
+			var str = body;
+			try {
+				debug("parse body");
+				str = typeof body !== "string" && encoding !== null ? iconv.decode(body, encoding) : body;
+				req.body = parse(str);
+			} catch (err) {
+				next(createError(400, err, {
+					body: str,
+					type: err.type || "entity.parse.failed"
+				}));
+				return;
+			}
+			next();
+		});
+	}
+	/**
+	* Get the content stream of the request.
+	*
+	* @param {object} req
+	* @param {function} debug
+	* @param {boolean} [inflate=true]
+	* @return {object}
+	* @api private
+	*/
+	function contentstream(req, debug, inflate) {
+		var encoding = (req.headers["content-encoding"] || "identity").toLowerCase();
+		var length = req.headers["content-length"];
+		var stream;
+		debug("content-encoding \"%s\"", encoding);
+		if (inflate === false && encoding !== "identity") throw createError(415, "content encoding unsupported", {
+			encoding,
+			type: "encoding.unsupported"
+		});
+		switch (encoding) {
+			case "deflate":
+				stream = zlib.createInflate();
+				debug("inflate body");
+				req.pipe(stream);
+				break;
+			case "gzip":
+				stream = zlib.createGunzip();
+				debug("gunzip body");
+				req.pipe(stream);
+				break;
+			case "identity":
+				stream = req;
+				stream.length = length;
+				break;
+			default: throw createError(415, "unsupported content encoding \"" + encoding + "\"", {
+				encoding,
+				type: "encoding.unsupported"
+			});
+		}
+		return stream;
+	}
+	/**
+	* Dump the contents of a request.
+	*
+	* @param {object} req
+	* @param {function} callback
+	* @api private
+	*/
+	function dump(req, callback) {
+		if (onFinished.isFinished(req)) callback(null);
+		else {
+			onFinished(req, callback);
+			req.resume();
+		}
+	}
+}));
+
+//#endregion
+export default require_read();
+
+export { require_read };