@opra/core 0.0.5

package/cjs/implementation/opra-service.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraService = void 0;
+const schema_1 = require("@opra/schema");
+const responsive_object_js_1 = require("../utils/responsive-object.js");
+const entity_type_js_1 = require("./data-type/entity-type.js");
+const opra_document_js_1 = require("./opra-document.js");
+const entity_resource_info_js_1 = require("./resource/entity-resource-info.js");
+const schema_generator_js_1 = require("./schema-generator.js");
+class OpraService extends opra_document_js_1.OpraDocument {
+    _resources = (0, responsive_object_js_1.Responsive)();
+    constructor(schema) {
+        super(schema);
+        if (schema.resources)
+            this._addResources(schema.resources);
+    }
+    get resources() {
+        return this._resources;
+    }
+    get servers() {
+        return this._args.servers;
+    }
+    getResource(name) {
+        const t = this.resources[name];
+        if (!t)
+            throw new Error(`Resource "${name}" does not exists`);
+        return t;
+    }
+    getEntityResource(name) {
+        const t = this.getResource(name);
+        if (!(t instanceof entity_resource_info_js_1.EntityResourceInfo))
+            throw new Error(`"${name}" is not an EntityResource`);
+        return t;
+    }
+    _addResources(resources) {
+        for (const r of resources) {
+            if (schema_1.OpraSchema.isEntityResource(r)) {
+                const dataType = this.getDataType(r.type);
+                if (!dataType)
+                    throw new TypeError(`Datatype "${r.type}" declared in EntityResource (${r.name}) does not exists`);
+                if (!(dataType instanceof entity_type_js_1.EntityType))
+                    throw new TypeError(`${r.type} is not an EntityType`);
+                this.resources[r.name] = new entity_resource_info_js_1.EntityResourceInfo({ ...r, service: this, dataType });
+            }
+            else
+                throw new TypeError(`Unknown resource kind (${r.kind})`);
+        }
+        // Sort data types by name
+        const newResources = (0, responsive_object_js_1.Responsive)();
+        Object.keys(this.resources).sort()
+            .forEach(name => newResources[name] = this.resources[name]);
+        this._resources = newResources;
+    }
+    static async create(args) {
+        const schema = await schema_generator_js_1.SchemaGenerator.generateServiceSchema(args);
+        return new OpraService(schema);
+    }
+}
+exports.OpraService = OpraService;

package/cjs/implementation/resource/container-resource-controller.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerResourceController = void 0;
+const entity_resource_info_js_1 = require("./entity-resource-info.js");
+const resource_info_js_1 = require("./resource-info.js");
+class ContainerResourceController extends resource_info_js_1.ResourceInfo {
+    constructor(args) {
+        super({
+            kind: 'ContainerResource',
+            ...args
+        });
+    }
+    getResource(name) {
+        const t = this._args.resources[name];
+        if (!t)
+            throw new Error(`Resource "${name}" does not exists`);
+        return t;
+    }
+    getEntityResource(name) {
+        const t = this.getResource(name);
+        if (!(t instanceof entity_resource_info_js_1.EntityResourceInfo))
+            throw new Error(`"${name}" is not an EntityResource`);
+        return t;
+    }
+}
+exports.ContainerResourceController = ContainerResourceController;

package/cjs/implementation/resource/entity-resource-info.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityResourceInfo = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const entity_type_js_1 = require("../data-type/entity-type.js");
+const resource_info_js_1 = require("./resource-info.js");
+class EntityResourceInfo extends resource_info_js_1.ResourceInfo {
+    service;
+    dataType;
+    constructor(args) {
+        super({
+            kind: 'EntityResource',
+            ...lodash_1.default.omit(args, ['dataType', 'service'])
+        });
+        this.dataType = args.dataType;
+        this.service = args.service;
+        // noinspection SuspiciousTypeOfGuard
+        if (!(args.dataType instanceof entity_type_js_1.EntityType))
+            throw new TypeError(`You should provide an EntityType for EntityResourceController`);
+    }
+    get search() {
+        return this._args.search;
+    }
+    get create() {
+        return this._args.create;
+    }
+    get read() {
+        return this._args.read;
+    }
+    get update() {
+        return this._args.update;
+    }
+    get updateAll() {
+        return this._args.updateMany;
+    }
+    get delete() {
+        return this._args.delete;
+    }
+    get deleteMany() {
+        return this._args.deleteMany;
+    }
+    async execute(ctx) {
+        const { query } = ctx.request;
+        const fn = this._args[query.queryType];
+        const result = typeof fn === 'function' ? (await fn(ctx)) : undefined;
+        if (query.queryType === 'search') {
+            ctx.response.value = Array.isArray(result)
+                ? result
+                : (ctx.response.value ? [result] : []);
+        }
+        else if (query.queryType === 'delete' ||
+            query.queryType === 'deleteMany' ||
+            query.queryType === 'updateMany') {
+            let affected = result;
+            if (affected && typeof affected === 'object')
+                affected = result.affected || result.affectedRows;
+            affected = typeof affected === 'number' ? affected :
+                (affected === false ? 0 : (affected ? 1 : 0));
+            ctx.response.value = {
+                affected
+            };
+        }
+        else
+            ctx.response.value = Array.isArray(result) ? result[0] : result;
+    }
+}
+exports.EntityResourceInfo = EntityResourceInfo;

package/cjs/implementation/resource/resource-info.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceInfo = void 0;
+const terminal_utils_js_1 = require("../../utils/terminal-utils.js");
+class ResourceInfo {
+    _args;
+    constructor(args) {
+        this._args = args;
+    }
+    get name() {
+        return this._args.name;
+    }
+    get description() {
+        return this._args.description;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [terminal_utils_js_1.nodeInspectCustom]() {
+        return `[${terminal_utils_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + terminal_utils_js_1.colorReset}` +
+            ` ${terminal_utils_js_1.colorFgMagenta + this.name + terminal_utils_js_1.colorReset}]`;
+    }
+}
+exports.ResourceInfo = ResourceInfo;

package/cjs/implementation/schema-generator.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaGenerator = void 0;
+const types_1 = require("util/types");
+const schema_1 = require("@opra/schema");
+const constants_js_1 = require("../constants.js");
+const class_utils_js_1 = require("../utils/class-utils.js");
+const internal_data_types_js_1 = require("../utils/internal-data-types.js");
+const entityMethods = ['search', 'create', 'read', 'update', 'updateMany', 'delete', 'deleteMany'];
+class SchemaGenerator {
+    _dataTypes = {};
+    _resources = {};
+    constructor() {
+        //
+    }
+    async addDataType(thunk) {
+        let schema;
+        thunk = (0, types_1.isPromise)(thunk) ? await thunk : thunk;
+        if (typeof thunk === 'function' && !(0, class_utils_js_1.isConstructor)(thunk))
+            thunk = await thunk();
+        if (!(0, class_utils_js_1.isConstructor)(thunk) || schema_1.OpraSchema.isDataType(thunk))
+            throw new TypeError(`Function must return a type class or type schema`);
+        if ((0, class_utils_js_1.isConstructor)(thunk)) {
+            const ctor = thunk;
+            const metadata = Reflect.getOwnMetadata(schema_1.DATATYPE_METADATA, ctor);
+            if (!metadata)
+                throw new TypeError(`Class "${ctor}" has no type metadata`);
+            schema = this._dataTypes[metadata.name];
+            if (schema) {
+                if (schema.kind !== metadata.kind ||
+                    (schema_1.OpraSchema.isComplexType(schema) && schema.ctor !== ctor))
+                    throw new Error(`An other instance of "${schema.name}" data type previously defined`);
+                return schema;
+            }
+            // Add base data type
+            let base;
+            let baseCtor = Object.getPrototypeOf(ctor);
+            if (Reflect.hasMetadata(schema_1.DATATYPE_METADATA, baseCtor)) {
+                while (!Reflect.hasOwnMetadata(schema_1.DATATYPE_METADATA, baseCtor)) {
+                    baseCtor = Object.getPrototypeOf(baseCtor);
+                }
+                const baseSchema = await this.addDataType(baseCtor);
+                base = baseSchema.name;
+            }
+            if (schema_1.OpraSchema.isComplexType(metadata) || schema_1.OpraSchema.isEntityType(metadata)) {
+                schema = {
+                    ...metadata,
+                    ctor,
+                    base
+                };
+                const properties = Reflect.getMetadata(schema_1.DATATYPE_PROPERTIES, ctor.prototype);
+                if (properties) {
+                    for (const [k, p] of Object.entries(properties)) {
+                        let type;
+                        if ((0, class_utils_js_1.isConstructor)(p.type) && internal_data_types_js_1.builtinClassMap.has(p.type))
+                            type = internal_data_types_js_1.builtinClassMap.get(p.type);
+                        else if (typeof p.type === 'function' || typeof p.type === 'object') {
+                            const t = await this.addDataType(p.type);
+                            type = t.name;
+                        }
+                        else
+                            type = p.type || 'string';
+                        if (internal_data_types_js_1.internalDataTypes.has(type) && !this._dataTypes[type])
+                            this._dataTypes[type] = internal_data_types_js_1.internalDataTypes.get(type.toLowerCase());
+                        schema.properties = schema.properties || {};
+                        schema.properties[k] = { ...p, type };
+                    }
+                }
+            }
+            else if (schema_1.OpraSchema.isSimpleType(metadata)) {
+                if (!internal_data_types_js_1.primitiveDataTypeNames.includes(metadata.type))
+                    throw new Error(`"type" of SimpleType schema must be one of enumerated value (${internal_data_types_js_1.primitiveDataTypeNames})`);
+                schema = {
+                    ...metadata
+                };
+            }
+            else
+                /* istanbul ignore next */
+                throw new TypeError(`Invalid metadata`);
+        }
+        else if (schema_1.OpraSchema.isDataType(thunk)) {
+            schema = thunk;
+        }
+        else
+            throw new TypeError(`Invalid data type schema`);
+        this._dataTypes[schema.name] = schema;
+        return schema;
+    }
+    async addResource(instance) {
+        if ((0, class_utils_js_1.isConstructor)(instance))
+            throw new Error(`You should provide Resource instance instead of Resource class`);
+        const proto = Object.getPrototypeOf(instance);
+        const ctor = proto.constructor;
+        const metadata = Reflect.getMetadata(constants_js_1.RESOURCE_METADATA, ctor);
+        let resourceSchema;
+        if (metadata) {
+            const name = metadata.name || ctor.name.replace(/Resource$/, '');
+            const t = typeof metadata.type === 'function'
+                ? await (0, class_utils_js_1.resolveClassAsync)(metadata.type)
+                : metadata.type;
+            const type = typeof t === 'function'
+                ? (await this.addDataType(t)).name
+                : t;
+            resourceSchema = {
+                ...metadata,
+                type,
+                name
+            };
+            if (schema_1.OpraSchema.isEntityResource(resourceSchema)) {
+                for (const methodName of entityMethods) {
+                    const fn = instance[methodName];
+                    if (typeof fn === 'function') {
+                        resourceSchema[methodName] = fn.bind(instance);
+                    }
+                }
+            }
+        }
+        else
+            resourceSchema = instance;
+        if (schema_1.OpraSchema.isResource(resourceSchema)) {
+            if (schema_1.OpraSchema.isEntityResource(resourceSchema)) {
+                const t = this._dataTypes[resourceSchema.type];
+                if (!t)
+                    throw new Error(`Resource registration error. Type "${resourceSchema.type}" not found.`);
+                if (this._resources[resourceSchema.name])
+                    throw new Error(`An other instance of "${resourceSchema.name}" resource previously defined`);
+                this._resources[resourceSchema.name] = resourceSchema;
+                return;
+            }
+            throw new Error(`Invalid resource metadata`);
+        }
+        throw new Error(`Invalid resource object`);
+    }
+    static async generateDocumentSchema(args) {
+        const generator = new SchemaGenerator();
+        if (args.types) {
+            for (const thunk of args.types) {
+                await generator.addDataType(thunk);
+            }
+        }
+        const types = Object.keys(generator._dataTypes).sort()
+            .map(name => generator._dataTypes[name]);
+        return {
+            version: '1',
+            ...args,
+            types
+        };
+    }
+    static async generateServiceSchema(args) {
+        const generator = new SchemaGenerator();
+        if (args.types) {
+            for (const thunk of args.types) {
+                await generator.addDataType(thunk);
+            }
+        }
+        if (args.resources) {
+            for (const resource of args.resources) {
+                await generator.addResource(resource);
+            }
+        }
+        const types = Object.keys(generator._dataTypes).sort()
+            .map(name => generator._dataTypes[name]);
+        const resources = Object.keys(generator._resources).sort()
+            .map(name => generator._resources[name]);
+        return {
+            version: '1',
+            ...args,
+            types,
+            resources
+        };
+    }
+}
+exports.SchemaGenerator = SchemaGenerator;

package/cjs/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("reflect-metadata");
+tslib_1.__exportStar(require("./constants.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./enums/index.js"), exports);
+tslib_1.__exportStar(require("./exception/index.js"), exports);
+tslib_1.__exportStar(require("./decorators/entity-resource.decorator.js"), exports);
+tslib_1.__exportStar(require("./interfaces/http-context.interface.js"), exports);
+tslib_1.__exportStar(require("./interfaces/execution-query.interface.js"), exports);
+tslib_1.__exportStar(require("./interfaces/entity-resource.interface.js"), exports);
+tslib_1.__exportStar(require("./interfaces/resource-container.interface.js"), exports);
+tslib_1.__exportStar(require("./implementation/execution-context.js"), exports);
+tslib_1.__exportStar(require("./implementation/opra-document.js"), exports);
+tslib_1.__exportStar(require("./implementation/opra-service.js"), exports);
+tslib_1.__exportStar(require("./implementation/schema-generator.js"), exports);
+tslib_1.__exportStar(require("./implementation/adapter/adapter.js"), exports);
+tslib_1.__exportStar(require("./implementation/adapter/express-adapter.js"), exports);
+tslib_1.__exportStar(require("./implementation/data-type/data-type.js"), exports);
+tslib_1.__exportStar(require("./implementation/data-type/complex-type.js"), exports);
+tslib_1.__exportStar(require("./implementation/data-type/simple-type.js"), exports);
+tslib_1.__exportStar(require("./implementation/resource/resource-info.js"), exports);
+tslib_1.__exportStar(require("./implementation/resource/entity-resource-info.js"), exports);
+tslib_1.__exportStar(require("./services/json-data-service.js"), exports);

package/cjs/interfaces/entity-resource.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/interfaces/execution-query.interface.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionQuery = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const complex_type_js_1 = require("../implementation/data-type/complex-type.js");
+const string_path_to_object_tree_js_1 = require("../utils/string-path-to-object-tree.js");
+var ExecutionQuery;
+(function (ExecutionQuery) {
+    function forCreate(resource, values, options) {
+        if (options?.pick)
+            options.pick = normalizePick(resource, options.pick);
+        if (options?.omit)
+            options.omit = normalizePick(resource, options.omit);
+        if (options?.include)
+            options.include = normalizePick(resource, options.include);
+        const out = {
+            queryType: 'create',
+            scope: 'collection',
+            operationType: 'create',
+            resource,
+            data: values
+        };
+        Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forCreate = forCreate;
+    function forRead(resource, key, options) {
+        if (options?.pick)
+            options.pick = normalizePick(resource, options.pick);
+        if (options?.omit)
+            options.omit = normalizePick(resource, options.omit);
+        if (options?.include)
+            options.include = normalizePick(resource, options.include);
+        checkKeyFields(resource, key);
+        const out = {
+            queryType: 'read',
+            scope: 'instance',
+            operationType: 'read',
+            resource,
+            keyValue: key
+        };
+        Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forRead = forRead;
+    function forSearch(resource, options) {
+        if (options?.pick)
+            options.pick = normalizePick(resource, options.pick);
+        if (options?.omit)
+            options.omit = normalizePick(resource, options.omit);
+        if (options?.include)
+            options.include = normalizePick(resource, options.include);
+        if (options?.sort)
+            options.sort = normalizePick(resource, options.sort); // todo check allowed sort fields
+        const out = {
+            queryType: 'search',
+            scope: 'collection',
+            operationType: 'read',
+            resource
+        };
+        Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forSearch = forSearch;
+    function forProperty(property, options) {
+        const out = {
+            queryType: 'read',
+            scope: 'property',
+            operationType: 'read',
+            property
+        };
+        Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forProperty = forProperty;
+    function forUpdate(resource, keyValue, values, options) {
+        if (options?.pick)
+            options.pick = normalizePick(resource, options.pick);
+        if (options?.omit)
+            options.omit = normalizePick(resource, options.omit);
+        if (options?.include)
+            options.include = normalizePick(resource, options.include);
+        checkKeyFields(resource, keyValue);
+        const out = {
+            queryType: 'update',
+            scope: 'instance',
+            operationType: 'update',
+            resource,
+            keyValue,
+            data: values
+        };
+        Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forUpdate = forUpdate;
+    function forUpdateMany(resource, values, options) {
+        const out = {
+            queryType: 'updateMany',
+            scope: 'collection',
+            operationType: 'update',
+            resource,
+            data: values
+        };
+        Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forUpdateMany = forUpdateMany;
+    function forDelete(resource, key) {
+        checkKeyFields(resource, key);
+        return {
+            queryType: 'delete',
+            scope: 'instance',
+            operationType: 'delete',
+            resource,
+            keyValue: key
+        };
+    }
+    ExecutionQuery.forDelete = forDelete;
+    function forDeleteMany(resource, options) {
+        const out = {
+            queryType: 'deleteMany',
+            scope: 'collection',
+            operationType: 'delete',
+            resource,
+        };
+        Object.assign(out, lodash_1.default.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forDeleteMany = forDeleteMany;
+    function isCreateQuery(q) {
+        return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'create';
+    }
+    ExecutionQuery.isCreateQuery = isCreateQuery;
+    function isSearchQuery(q) {
+        return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'search';
+    }
+    ExecutionQuery.isSearchQuery = isSearchQuery;
+    function isReadQuery(q) {
+        return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'read';
+    }
+    ExecutionQuery.isReadQuery = isReadQuery;
+    function isDeleteQuery(q) {
+        return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'delete';
+    }
+    ExecutionQuery.isDeleteQuery = isDeleteQuery;
+})(ExecutionQuery = exports.ExecutionQuery || (exports.ExecutionQuery = {}));
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function checkKeyFields(resource, key) {
+    if (!resource.dataType.primaryKey)
+        throw new Error(`"${resource.name}" has no primary key`);
+}
+function normalizePick(resource, fields) {
+    const fieldsTree = (0, string_path_to_object_tree_js_1.stringPathToObjectTree)(fields) || {};
+    return _normalizeFieldsList([], resource.service, resource, resource.dataType, fieldsTree, '', {
+        additionalProperties: true
+    });
+}
+function _normalizeFieldsList(target, service, resource, dataType, node, parentPath = '', options) {
+    let curPath = '';
+    for (const k of Object.keys(node)) {
+        const nodeVal = node[k];
+        const prop = dataType?.properties?.[k];
+        if (!prop) {
+            curPath = parentPath ? parentPath + '.' + k : k;
+            if (!options?.additionalProperties || (dataType && !dataType.additionalProperties))
+                throw new TypeError(`Unknown field path "${resource.name + '.' + curPath}"`);
+            if (typeof nodeVal === 'object')
+                _normalizeFieldsList(target, service, resource, undefined, nodeVal, curPath, options);
+            else
+                target.push(curPath);
+            continue;
+        }
+        curPath = parentPath ? parentPath + '.' + prop.name : prop.name;
+        const propType = service.getDataType(prop.type || 'string');
+        if (typeof nodeVal === 'object') {
+            if (!(propType instanceof complex_type_js_1.ComplexType))
+                throw new TypeError(`"${curPath}" is not a complex type and has no sub fields`);
+            if (target.findIndex(x => x === parentPath) >= 0)
+                continue;
+            target = _normalizeFieldsList(target, service, resource, propType, nodeVal, curPath, options);
+            continue;
+        }
+        if (target.findIndex(x => x.startsWith(curPath + '.')) >= 0) {
+            target = target.filter(x => !x.startsWith(curPath + '.'));
+        }
+        target.push(curPath);
+    }
+    return target;
+}

package/cjs/interfaces/http-context.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/interfaces/opra-schema.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/interfaces/resource-container.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/services/data-service.js

@@ -0,0 +1,9 @@
+"use strict";
+/* eslint-disable */
+// import { Type } from 'ts-gems';
+//  import { ComplexType } from '../implementation/data-type/complex-type.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataService = void 0;
+class DataService {
+}
+exports.DataService = DataService;

package/cjs/services/json-data-service.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonDataService = void 0;
+const tslib_1 = require("tslib");
+const rule_judgment_1 = tslib_1.__importDefault(require("rule-judgment"));
+const data_service_js_1 = require("./data-service.js");
+// Fix invalid importing (with ESM) of rule-judgment package
+const toArrayFilter = typeof rule_judgment_1.default === 'function' ? rule_judgment_1.default : rule_judgment_1.default.default;
+class JsonDataService extends data_service_js_1.DataService {
+    data;
+    constructor(args) {
+        super();
+    }
+}
+exports.JsonDataService = JsonDataService;

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/utils/class-utils.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInternalClass = exports.resolveClassAsync = exports.resolveClass = exports.isConstructor = void 0;
+const knownInternalClasses = [String, Number, Boolean, Date];
+function isConstructor(obj) {
+    return typeof obj === 'function' &&
+        !!(obj.prototype && obj.prototype.constructor);
+}
+exports.isConstructor = isConstructor;
+function resolveClass(typeOrFunc) {
+    if (typeof typeOrFunc === 'function' && !isConstructor(typeOrFunc)) {
+        typeOrFunc = typeOrFunc();
+        if (isConstructor(typeOrFunc))
+            return typeOrFunc;
+        throw new TypeError(`Function must return a constructor`);
+    }
+    if (isConstructor(typeOrFunc))
+        return typeOrFunc;
+    throw new TypeError(`${typeOrFunc} is not a constructor`);
+}
+exports.resolveClass = resolveClass;
+async function resolveClassAsync(typeOrFunc) {
+    if (typeof typeOrFunc === 'function' && !isConstructor(typeOrFunc)) {
+        typeOrFunc = await typeOrFunc();
+        if (isConstructor(typeOrFunc))
+            return typeOrFunc;
+        throw new TypeError(`Function must return a constructor`);
+    }
+    if (isConstructor(typeOrFunc))
+        return typeOrFunc;
+    throw new TypeError(`${typeOrFunc} is not a constructor`);
+}
+exports.resolveClassAsync = resolveClassAsync;
+function isInternalClass(t) {
+    return knownInternalClasses.includes(t) || Buffer.isBuffer(t);
+}
+exports.isInternalClass = isInternalClass;