@opra/common 0.18.4 → 0.19.0

package/cjs/document/data-type/simple-type.js

@@ -3,58 +3,59 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleType = void 0;
 const tslib_1 = require("tslib");
 const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
-const index_js_1 = require("../../helpers/index.js");
-const index_js_2 = require("../../schema/index.js");
+const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const vg = tslib_1.__importStar(require("valgen"));
+const index_js_1 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
 const data_type_js_1 = require("./data-type.js");
 /**
  * @class SimpleType
  */
-exports.SimpleType = function (...args) {
-    // ClassDecorator
-    if (!this) {
-        const [options] = args;
-        return function (target) {
-            let name = options?.name || target.name.match(constants_js_1.TYPENAME_PATTERN)?.[1] || target.name;
-            name = name.charAt(0).toLowerCase() + name.substring(1);
-            const metadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, target) || {};
-            metadata.kind = index_js_2.OpraSchema.SimpleType.Kind;
-            metadata.name = name;
-            if (options)
-                Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'name', 'base']));
-            Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, target);
-        };
+class SimpleTypeClass extends data_type_js_1.DataType {
+    constructor(document, init) {
+        super(document, init);
+        this.kind = index_js_1.OpraSchema.SimpleType.Kind;
+        this.base = init.base;
+        this._decoder = init.decoder || init.base?._decoder || vg.isAny();
+        this._encoder = init.encoder || init.base?._encoder || vg.isAny();
+    }
+    _getDecoder() {
+        return this._decoder;
+    }
+    _getEncoder() {
+        return this._encoder;
     }
-    // Constructor
-    const [, options] = args;
-    // call super()
-    data_type_js_1.DataType.apply(this, args);
-    const _this = this;
-    _this.kind = index_js_2.OpraSchema.SimpleType.Kind;
-    _this.base = options?.base;
-    const own = _this.own;
-    own.codec = options?.codec;
-    own.ctor = options?.ctor;
-    if (options?.pattern)
-        own.pattern = (options?.pattern instanceof RegExp ? options.pattern : new RegExp(options.pattern));
-    const ctor = own.ctor || _this.base?.ctor;
-    _this.ctor = ctor || Object;
-    _this.decode = own.codec?.decode || _this.base?.decode || ((v) => v);
-    _this.encode = own.codec?.encode || _this.base?.encode || ((v) => v);
-    _this.coerce = own.codec?.coerce || _this.base?.coerce || ((v) => v);
-    _this.validate = own.codec?.validate || _this.base?.validate || (() => true);
-    _this.pattern = own.pattern || _this.base?.pattern;
-};
-const proto = {
     exportSchema() {
-        const out = data_type_js_1.DataType.prototype.exportSchema.call(this);
-        Object.assign(out, (0, index_js_1.omitUndefined)({
-            base: this.base ?
-                (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
-            pattern: this.own.pattern
-        }));
+        // noinspection UnnecessaryLocalVariableJS
+        const out = super.exportSchema();
+        // Object.assign(out, omitUndefined({
+        //   base: this.base ?
+        //       (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
+        // }));
         return out;
     }
+}
+/**
+ * @class SimpleType
+ */
+exports.SimpleType = function (...args) {
+    // Constructor
+    if (this) {
+        const [document, init] = args;
+        (0, putil_merge_1.default)(this, new SimpleTypeClass(document, init), { descriptor: true });
+        return;
+    }
+    // ClassDecorator
+    const [options] = args;
+    return function (target) {
+        let name = options?.name || target.name.match(constants_js_1.TYPENAME_PATTERN)?.[1] || target.name;
+        name = name.charAt(0).toLowerCase() + name.substring(1);
+        const metadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, target) || {};
+        metadata.kind = index_js_1.OpraSchema.SimpleType.Kind;
+        metadata.name = name;
+        if (options)
+            Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'name']));
+        Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, target);
+    };
 };
-Object.assign(exports.SimpleType.prototype, proto);
-Object.setPrototypeOf(exports.SimpleType.prototype, data_type_js_1.DataType.prototype);
+exports.SimpleType.prototype = SimpleTypeClass.prototype;

package/cjs/document/data-type/union-type.js

@@ -1,56 +1,87 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnionType = void 0;
+const tslib_1 = require("tslib");
+const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const vg = tslib_1.__importStar(require("valgen"));
 const index_js_1 = require("../../helpers/index.js");
 const index_js_2 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
 const complex_type_js_1 = require("./complex-type.js");
 const data_type_js_1 = require("./data-type.js");
 const mapped_type_js_1 = require("./mapped-type.js");
-/**
- * @class UnionType
- */
-exports.UnionType = function (...args) {
-    // UnionType helper
-    if (!this) {
-        return mapToUnionType(...args);
-    }
-    // Constructor
-    // call super()
-    data_type_js_1.DataType.apply(this, args);
-    const [, init] = args;
-    const _this = this;
-    _this.fields = new index_js_1.ResponsiveMap();
-    const own = _this.own;
-    own.types = [];
-    for (const base of init.types) {
-        if (!(base instanceof complex_type_js_1.ComplexType || base instanceof exports.UnionType || base instanceof mapped_type_js_1.MappedType))
-            throw new TypeError(`${index_js_2.OpraSchema.UnionType.Kind} shall contain ${index_js_2.OpraSchema.ComplexType.Kind}, ` +
-                `${index_js_2.OpraSchema.UnionType.Kind} of ${index_js_2.OpraSchema.MappedType.Kind} types.`);
-        own.types.push(base);
-        if (base.additionalFields)
-            _this.additionalFields = true;
-        _this.fields.setAll(base.fields);
+class UnionTypeClass extends data_type_js_1.DataType {
+    constructor(document, init) {
+        super(document, init);
+        this.kind = index_js_2.OpraSchema.UnionType.Kind;
+        this.fields = new index_js_1.ResponsiveMap();
+        const own = this.own;
+        own.types = [];
+        for (const base of init.types) {
+            if (!(base instanceof complex_type_js_1.ComplexType || base instanceof exports.UnionType || base instanceof mapped_type_js_1.MappedType))
+                throw new TypeError(`${index_js_2.OpraSchema.UnionType.Kind} shall contain ${index_js_2.OpraSchema.ComplexType.Kind}, ` +
+                    `${index_js_2.OpraSchema.UnionType.Kind} of ${index_js_2.OpraSchema.MappedType.Kind} types.`);
+            own.types.push(base);
+            if (base.additionalFields)
+                this.additionalFields = true;
+            this.fields.setAll(base.fields);
+        }
+        this.types = [...own.types];
     }
-    _this.kind = 'UnionType';
-    _this.types = [...own.types];
-};
-exports.UnionType._applyMixin = () => void 0;
-const proto = {
     exportSchema() {
-        const out = data_type_js_1.DataType.prototype.exportSchema.call(this);
+        const out = super.exportSchema();
         Object.assign(out, (0, index_js_1.omitUndefined)({
             types: this.own.types.map(t => t.name ? t.name : t.exportSchema())
         }));
         return out;
     }
-};
-Object.assign(exports.UnionType.prototype, proto);
-Object.setPrototypeOf(exports.UnionType.prototype, data_type_js_1.DataType.prototype);
+    _getDecoder() {
+        if (this._decoder)
+            return this._decoder;
+        const schema = {};
+        for (const f of this.fields.values()) {
+            let t = f.type.getDecoder();
+            if (f.isArray)
+                t = vg.isArray(t);
+            schema[f.name] = t;
+        }
+        this._decoder = vg.isObject(schema, {
+            additionalFields: this.additionalFields,
+            name: this.name,
+            caseInSensitive: true
+        });
+        return this._decoder;
+    }
+    _getEncoder() {
+        if (this._encoder)
+            return this._encoder;
+        const schema = {};
+        for (const f of this.fields.values()) {
+            let t = f.type.getEncoder();
+            if (f.isArray)
+                t = vg.isArray(t);
+            schema[f.name] = t;
+        }
+        this._encoder = vg.isObject(schema, {
+            additionalFields: this.additionalFields,
+            name: this.name,
+            caseInSensitive: true,
+            detectCircular: true
+        });
+        return this._encoder;
+    }
+}
 /**
- *
+ * @class UnionType
  */
-function mapToUnionType(...args) {
+exports.UnionType = function (...args) {
+    // Constructor
+    if (this) {
+        const [document, init] = args;
+        (0, putil_merge_1.default)(this, new UnionTypeClass(document, init), { descriptor: true });
+        return;
+    }
+    // UnionType helper
     // Filter undefined items
     const clasRefs = [...args].filter(x => !!x);
     if (!clasRefs.length)
@@ -78,4 +109,6 @@ function mapToUnionType(...args) {
     }
     exports.UnionType._applyMixin(UnionClass, ...clasRefs);
     return UnionClass;
-}
+};
+exports.UnionType.prototype = UnionTypeClass.prototype;
+exports.UnionType._applyMixin = () => void 0;

package/cjs/document/factory/create-document.js

@@ -11,6 +11,8 @@ async function createDocument(init, options) {
     if (!options?.noBuiltinTypes) {
         const builtinDocument = await this.createBuiltinTypeDocument();
         this.document.references.set('Opra', builtinDocument);
+        for (const [c, s] of Object.getPrototypeOf(this).constructor.designTypeMap.entries())
+            this.document._designTypeMap.set(c, s);
     }
     if (init.references)
         await this.addReferences(init.references);
@@ -69,9 +71,9 @@ async function createBuiltinTypeDocument() {
                 name: 'MIT'
             }
         },
-        types: [index_js_2.AnyType, index_js_2.Base64Type, index_js_2.BigIntType, index_js_2.BooleanType,
-            index_js_2.DateType, index_js_2.GuidType, index_js_2.IntegerType, index_js_2.NumberType,
-            index_js_2.ObjectType, index_js_2.StringType
+        types: [index_js_2.AnyType, index_js_2.Base64Type, index_js_2.BigintType, index_js_2.BooleanType,
+            index_js_2.DateType, index_js_2.UuidType, index_js_2.IntegerType, index_js_2.NumberType,
+            index_js_2.ObjectType, index_js_2.StringType, index_js_2.TimeType, index_js_2.TimestampType
         ]
     };
     const factoryClass = Object.getPrototypeOf(this).constructor;

package/cjs/document/factory/factory.js

@@ -1,4 +1,5 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocumentFactory = void 0;
 const index_js_1 = require("../../helpers/index.js");
@@ -38,25 +39,27 @@ class DocumentFactory {
     }
 }
 exports.DocumentFactory = DocumentFactory;
+_a = DocumentFactory;
+DocumentFactory.designTypeMap = new Map();
 (() => {
-    DocumentFactory.prototype.createDocument = create_document_js_1.createDocument;
-    DocumentFactory.prototype.createDocumentFromUrl = create_document_js_1.createDocumentFromUrl;
-    DocumentFactory.prototype.createBuiltinTypeDocument = create_document_js_1.createBuiltinTypeDocument;
-    DocumentFactory.prototype.addReferences = add_references_js_1.addReferences;
-    DocumentFactory.prototype.importTypeClass = import_type_class_js_1.importTypeClass;
-    DocumentFactory.prototype.extractSimpleTypeSchema = import_type_class_js_1.extractSimpleTypeSchema;
-    DocumentFactory.prototype.extractComplexTypeSchema = import_type_class_js_1.extractComplexTypeSchema;
-    DocumentFactory.prototype.extractMappedTypeSchema = import_type_class_js_1.extractMappedTypeSchema;
-    DocumentFactory.prototype.extractUnionTypeSchema = import_type_class_js_1.extractUnionTypeSchema;
-    DocumentFactory.prototype.extractEnumTypeSchema = import_type_class_js_1.extractEnumTypeSchema;
-    DocumentFactory.prototype.extractFieldSchema = import_type_class_js_1.extractFieldSchema;
-    DocumentFactory.prototype.processTypes = process_types_js_1.processTypes;
-    DocumentFactory.prototype.createDataTypeInstance = process_types_js_1.createDataTypeInstance;
-    DocumentFactory.prototype.addDataType = process_types_js_1.addDataType;
-    DocumentFactory.prototype.importResourceClass = import_resource_class_js_1.importResourceClass;
-    DocumentFactory.prototype.extractSingletonSchema = import_resource_class_js_1.extractSingletonSchema;
-    DocumentFactory.prototype.extractCollectionSchema = import_resource_class_js_1.extractCollectionSchema;
-    DocumentFactory.prototype.processResourceQueue = process_resources_js_1.processResourceQueue;
-    DocumentFactory.prototype.createCollection = process_resources_js_1.createCollection;
-    DocumentFactory.prototype.createSingleton = process_resources_js_1.createSingleton;
+    _a.prototype.createDocument = create_document_js_1.createDocument;
+    _a.prototype.createDocumentFromUrl = create_document_js_1.createDocumentFromUrl;
+    _a.prototype.createBuiltinTypeDocument = create_document_js_1.createBuiltinTypeDocument;
+    _a.prototype.addReferences = add_references_js_1.addReferences;
+    _a.prototype.importTypeClass = import_type_class_js_1.importTypeClass;
+    _a.prototype.extractSimpleTypeSchema = import_type_class_js_1.extractSimpleTypeSchema;
+    _a.prototype.extractComplexTypeSchema = import_type_class_js_1.extractComplexTypeSchema;
+    _a.prototype.extractMappedTypeSchema = import_type_class_js_1.extractMappedTypeSchema;
+    _a.prototype.extractUnionTypeSchema = import_type_class_js_1.extractUnionTypeSchema;
+    _a.prototype.extractEnumTypeSchema = import_type_class_js_1.extractEnumTypeSchema;
+    _a.prototype.extractFieldSchema = import_type_class_js_1.extractFieldSchema;
+    _a.prototype.processTypes = process_types_js_1.processTypes;
+    _a.prototype.createDataTypeInstance = process_types_js_1.createDataTypeInstance;
+    _a.prototype.addDataType = process_types_js_1.addDataType;
+    _a.prototype.importResourceClass = import_resource_class_js_1.importResourceClass;
+    _a.prototype.extractSingletonSchema = import_resource_class_js_1.extractSingletonSchema;
+    _a.prototype.extractCollectionSchema = import_resource_class_js_1.extractCollectionSchema;
+    _a.prototype.processResourceQueue = process_resources_js_1.processResourceQueue;
+    _a.prototype.createCollection = process_resources_js_1.createCollection;
+    _a.prototype.createSingleton = process_resources_js_1.createSingleton;
 })();

package/cjs/document/factory/import-type-class.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractFieldSchema = exports.extractEnumTypeSchema = exports.extractUnionTypeSchema = exports.extractMappedTypeSchema = exports.extractComplexTypeSchema = exports.extractSimpleTypeSchema = exports.importTypeClass = void 0;
+const valgen_1 = require("valgen");
 const index_js_1 = require("../../helpers/index.js");
 const index_js_2 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
@@ -67,14 +68,17 @@ metadata) {
     const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
     if (Reflect.hasMetadata(constants_js_1.METADATA_KEY, baseClass))
         target.base = await this.importTypeClass(baseClass);
-    target.codec = Object.create(ctor.prototype);
+    if (typeof ctor.prototype.decode === 'function')
+        target.decoder = (0, valgen_1.validator)(metadata.name, ctor.prototype.decode);
+    if (typeof ctor.prototype.encode === 'function')
+        target.encoder = (0, valgen_1.validator)(metadata.name, ctor.prototype.encode);
 }
 exports.extractSimpleTypeSchema = extractSimpleTypeSchema;
 async function extractComplexTypeSchema(target, ctor, metadata) {
     const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
     if (Reflect.hasMetadata(constants_js_1.METADATA_KEY, baseClass))
         target.base = await this.importTypeClass(baseClass);
-    target.ctor = ctor;
+    target.ctor = target.ctor || ctor;
     // Fields
     if (metadata.fields) {
         const fields = target.fields = {};
@@ -90,8 +94,13 @@ async function extractComplexTypeSchema(target, ctor, metadata) {
                 };
                 if (elemMeta.enum)
                     elemSchema.type = await this.importTypeClass(elemMeta.enum);
-                if (!elemSchema.type && elemMeta.designType)
-                    elemSchema.type = await this.importTypeClass(elemMeta.designType);
+                if (!elemSchema.type && elemMeta.designType) {
+                    const mappingType = this.document.getDataType(elemMeta.designType, true);
+                    if (mappingType)
+                        elemSchema.type = mappingType.name;
+                    else
+                        elemSchema.type = await this.importTypeClass(elemMeta.designType);
+                }
                 await this.extractFieldSchema(elemSchema, ctor, elemMeta, elemName);
                 // Check enum again. External packages may modify enum value
                 if (elemMeta.enum)

package/cjs/document/resource/collection.js

@@ -14,64 +14,28 @@ const simple_type_js_1 = require("../data-type/simple-type.js");
 const resource_js_1 = require("./resource.js");
 const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
 const NAME_PATTERN = /^(.*)(Resource|Collection)$/;
-/**
- *
- */
-exports.Collection = function (...args) {
-    // ClassDecorator
-    if (!this) {
-        const [type, options] = args;
-        return function (target) {
-            const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
-            const metadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, target) || {};
-            const baseMetadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, Object.getPrototypeOf(target));
-            if (baseMetadata) {
-                (0, putil_merge_1.default)(metadata, baseMetadata, { deep: true });
-            }
-            metadata.kind = index_js_5.OpraSchema.Collection.Kind;
-            metadata.name = name;
-            metadata.type = type;
-            // Merge with previous metadata object
-            const m = Reflect.getMetadata(constants_js_1.METADATA_KEY, target);
-            if (m && metadata !== m)
-                Object.assign(metadata, (0, lodash_omit_1.default)(m), Object.keys(metadata));
-            // Merge options
-            if (options)
-                Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'name', 'type', 'controller']));
-            Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, target);
-            /* Define Injectable metadata for NestJS support*/
-            Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
-        };
-    }
-    // Constructor
-    const [document, init] = args;
-    // call super()
-    resource_js_1.Resource.apply(this, [document, init]);
-};
-const proto = {
-    _construct(init) {
-        // call super()
-        resource_js_1.Resource.prototype._construct.call(this, init);
-        const _this = this;
-        _this.kind = index_js_5.OpraSchema.Collection.Kind;
-        _this.controller = init.controller;
-        const operations = _this.operations = init.operations || {};
-        const dataType = _this.type = init.type;
+class CollectionClass extends resource_js_1.Resource {
+    constructor(document, init) {
+        super(document, init);
+        this.kind = index_js_5.OpraSchema.Collection.Kind;
+        this.controller = init.controller;
+        const operations = this.operations = init.operations || {};
+        const dataType = this.type = init.type;
         // Validate key fields
-        _this.primaryKey = init.primaryKey
+        this.primaryKey = init.primaryKey
             ? (Array.isArray(init.primaryKey) ? init.primaryKey : [init.primaryKey])
             : [];
-        if (!_this.primaryKey.length)
-            throw new TypeError(`You must provide primaryKey for Collection resource ("${_this.name}")`);
-        _this.primaryKey.forEach(f => {
+        if (!this.primaryKey.length)
+            throw new TypeError(`You must provide primaryKey for Collection resource ("${this.name}")`);
+        this.primaryKey.forEach(f => {
             const field = dataType.getField(f);
             if (!(field?.type instanceof simple_type_js_1.SimpleType))
                 throw new TypeError(`Only Simple type allowed for primary keys but "${f}" is a ${field.type.kind}`);
         });
-        if (_this.controller) {
-            const instance = typeof _this.controller == 'function'
-                ? new _this.controller()
-                : _this.controller;
+        if (this.controller) {
+            const instance = typeof this.controller == 'function'
+                ? new this.controller()
+                : this.controller;
             for (const operation of Object.values(operations)) {
                 if (!operation.handler && operation.handlerName) {
                     const fn = instance[operation.handlerName];
@@ -81,7 +45,7 @@ const proto = {
                 }
             }
         }
-    },
+    }
     exportSchema() {
         const out = resource_js_1.Resource.prototype.exportSchema.call(this);
         Object.assign(out, (0, index_js_3.omitUndefined)({
@@ -90,7 +54,7 @@ const proto = {
             primaryKey: this.primaryKey
         }));
         return out;
-    },
+    }
     parseKeyValue(value) {
         if (!this.primaryKey?.length)
             return;
@@ -121,22 +85,22 @@ const proto = {
                 throw new TypeError(`You must provide value of primary field(s) (${primaryKey})`);
             return result;
         }
-    },
+    }
     normalizeFieldPath(path) {
         return this.type.normalizeFieldPath(path);
-    },
+    }
     normalizeSortFields(fields) {
         const normalized = this.type.normalizeFieldPath(fields);
         const findManyEndpoint = this.operations.findMany;
         const sortFields = findManyEndpoint && findManyEndpoint.sortFields;
-        normalized.forEach(field => {
+        (Array.isArray(normalized) ? normalized : [normalized]).forEach(field => {
             if (!sortFields?.find(x => x === field))
                 throw new index_js_1.BadRequestError({
                     message: (0, index_js_4.translate)('error:UNACCEPTED_SORT_FIELD', { field }, `Field '${field}' is not available for sort operation`),
                 });
         });
         return normalized;
-    },
+    }
     normalizeFilter(filter) {
         if (!filter)
             return;
@@ -166,9 +130,41 @@ const proto = {
         }
         return ast;
     }
+}
+/**
+ *
+ */
+exports.Collection = function (...args) {
+    // ClassDecorator
+    if (!this) {
+        const [type, options] = args;
+        return function (target) {
+            const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+            const metadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, target) || {};
+            const baseMetadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, Object.getPrototypeOf(target));
+            if (baseMetadata) {
+                (0, putil_merge_1.default)(metadata, baseMetadata, { deep: true });
+            }
+            metadata.kind = index_js_5.OpraSchema.Collection.Kind;
+            metadata.name = name;
+            metadata.type = type;
+            // Merge with previous metadata object
+            const m = Reflect.getMetadata(constants_js_1.METADATA_KEY, target);
+            if (m && metadata !== m)
+                Object.assign(metadata, (0, lodash_omit_1.default)(m), Object.keys(metadata));
+            // Merge options
+            if (options)
+                Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'name', 'type', 'controller']));
+            Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, target);
+            /* Define Injectable metadata for NestJS support*/
+            Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
+        };
+    }
+    // Constructor
+    const [document, init] = args;
+    (0, putil_merge_1.default)(this, new CollectionClass(document, init), { descriptor: true });
 };
-Object.assign(exports.Collection.prototype, proto);
-Object.setPrototypeOf(exports.Collection.prototype, resource_js_1.Resource.prototype);
+exports.Collection.prototype = CollectionClass.prototype;
 function createOperationDecorator(operation) {
     return (options) => ((target, propertyKey) => {
         const metadata = {

package/cjs/document/resource/resource.js

@@ -3,36 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Resource = void 0;
 const object_utils_js_1 = require("../../helpers/object-utils.js");
 const inspect_util_js_1 = require("../utils/inspect.util.js");
-exports.Resource = function (document, init) {
-    if (!(this instanceof exports.Resource)) {
-        throw new TypeError(`Class constructor must be called with "new" keyword`);
-        // noinspection UnreachableCodeJS
-        return;
+class Resource {
+    constructor(document, init) {
+        this.document = document;
+        this.name = init.name;
+        this.description = init.description;
+        this.controller = init.controller;
     }
-    const _this = this;
-    _this.document = document;
-    _this.name = init.name;
-    _this.description = init.description;
-    _this.controller = init.controller;
-    _this._construct(init);
-};
-const proto = {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _construct(init) {
-        // Do nothing
-    },
     exportSchema() {
         return (0, object_utils_js_1.omitUndefined)({
             kind: this.kind,
             description: this.description
         });
-    },
+    }
     toString() {
         return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || '#anonymous'}]`;
-    },
+    }
     [inspect_util_js_1.nodeInspectCustom]() {
         return `[${inspect_util_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + inspect_util_js_1.colorReset}` +
             ` ${inspect_util_js_1.colorFgMagenta + this.name + inspect_util_js_1.colorReset}]`;
     }
-};
-Object.assign(exports.Resource.prototype, proto);
+}
+exports.Resource = Resource;