@opra/common 0.25.5 → 0.26.0

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

@@ -1,146 +0,0 @@
-"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");
-async function importTypeClass(typeThunk) {
-    const { document, typeQueue, cache } = this;
-    const thunk = await (0, index_js_1.resolveThunk)(typeThunk);
-    const cached = cache.get(thunk);
-    if (cached)
-        return cached;
-    const dt = document.getDataType(thunk, true);
-    if (dt && dt.name)
-        return dt.name;
-    const metadata = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, thunk);
-    if (!(metadata && index_js_2.OpraSchema.isDataType(metadata))) {
-        // If thunk is a Type class
-        if ((0, index_js_1.isConstructor)(thunk))
-            throw new TypeError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
-        // If thunk is an Enum object
-        throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(thunk).substring(0, 20)}...`);
-    }
-    // Clone metadata to prevent changing its contents
-    const name = metadata.name;
-    const schema = (0, index_js_1.cloneObject)(metadata);
-    const result = name || schema;
-    if (name) {
-        if (this.document.types.has(name) || typeQueue.has(name))
-            throw new TypeError(`Type "${name}" already imported`);
-        cache.set(thunk, result);
-        typeQueue.set(name, schema);
-    }
-    // If thunk is a DataType class
-    if ((0, index_js_1.isConstructor)(thunk)) {
-        const ctor = thunk;
-        if (index_js_2.OpraSchema.isSimpleType(schema))
-            await this.extractSimpleTypeSchema(schema, ctor, metadata);
-        else if (index_js_2.OpraSchema.isComplexType(schema))
-            await this.extractComplexTypeSchema(schema, ctor, metadata);
-        else if (index_js_2.OpraSchema.isMappedType(schema))
-            await this.extractMappedTypeSchema(schema, ctor, metadata);
-        else if (index_js_2.OpraSchema.isUnionType(schema))
-            await this.extractUnionTypeSchema(schema, ctor, metadata);
-        else
-            throw new TypeError(`Class "${ctor.name}" doesn't have a valid DataType metadata`);
-        return result;
-    }
-    // If thunk is a EnumType object
-    const enumObject = thunk;
-    if (index_js_2.OpraSchema.isEnumType(schema)) {
-        let baseType;
-        if (metadata.base && Reflect.hasMetadata(constants_js_1.DATATYPE_METADATA, metadata.base)) {
-            baseType = await this.importTypeClass(metadata.base);
-        }
-        schema.base = baseType;
-        await this.extractEnumTypeSchema(schema, enumObject, metadata);
-        return result;
-    }
-    throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(enumObject).substring(0, 20)}...`);
-}
-exports.importTypeClass = importTypeClass;
-// noinspection JSUnusedLocalSymbols
-async function extractSimpleTypeSchema(target, ctor, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-metadata) {
-    const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-    if (Reflect.hasMetadata(constants_js_1.DATATYPE_METADATA, baseClass))
-        target.base = await this.importTypeClass(baseClass);
-    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.DATATYPE_METADATA, baseClass))
-        target.base = await this.importTypeClass(baseClass);
-    target.ctor = target.ctor || ctor;
-    // Fields
-    if (metadata.fields) {
-        const fields = target.fields = {};
-        for (const [elemName, elemMeta] of Object.entries(metadata.fields)) {
-            try {
-                const t = await elemMeta.type;
-                const type = typeof t === 'function'
-                    ? await this.importTypeClass(t)
-                    : (t || '');
-                const elemSchema = fields[elemName] = {
-                    ...elemMeta,
-                    type
-                };
-                if (elemMeta.enum)
-                    elemSchema.type = await this.importTypeClass(elemMeta.enum);
-                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)
-                    elemSchema.type = await this.importTypeClass(elemMeta.enum);
-                if (typeof elemSchema.type === 'function')
-                    elemSchema.type = await this.importTypeClass(elemSchema.type);
-                if (elemSchema.isArray && !elemSchema.type)
-                    throw new TypeError(`"type" must be defined explicitly for array properties`);
-                elemSchema.type = elemSchema.type || 'any';
-            }
-            catch (e) {
-                e.message = `Error in class "${ctor.name}.${elemName}". ` + e.message;
-                throw e;
-            }
-        }
-    }
-}
-exports.extractComplexTypeSchema = extractComplexTypeSchema;
-async function extractMappedTypeSchema(target, ctor, metadata) {
-    target.type = await this.importTypeClass(metadata.type);
-}
-exports.extractMappedTypeSchema = extractMappedTypeSchema;
-async function extractUnionTypeSchema(target, ctor, metadata) {
-    const oldTypes = metadata.types;
-    target.types = [];
-    for (const type of oldTypes)
-        target.types.push(await this.importTypeClass(type));
-}
-exports.extractUnionTypeSchema = extractUnionTypeSchema;
-// noinspection JSUnusedLocalSymbols
-async function extractEnumTypeSchema(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-target, enumObject, metadata) {
-    // Do nothing. This method is used by external modules for extending the factory
-}
-exports.extractEnumTypeSchema = extractEnumTypeSchema;
-// noinspection JSUnusedLocalSymbols
-async function extractFieldSchema(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-target, ctor, metadata, name) {
-    // Do nothing. This method is used by external modules for extending the factory
-}
-exports.extractFieldSchema = extractFieldSchema;

package/cjs/document/factory/index.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./factory.js"), exports);

package/cjs/document/factory/process-resources.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStorageResource = exports.createSingletonResource = exports.createCollectionResource = exports.processSourceQueue = void 0;
-const index_js_1 = require("../../schema/index.js");
-const collection_js_1 = require("../resource/collection.js");
-const singleton_js_1 = require("../resource/singleton.js");
-const storage_js_1 = require("../resource/storage.js");
-async function processSourceQueue() {
-    const { document, sourceQueue } = this;
-    const sourceNames = Array.from(sourceQueue.keys());
-    for (const name of sourceNames) {
-        const schema = sourceQueue.get(name);
-        if (!schema)
-            continue;
-        try {
-            if (index_js_1.OpraSchema.isCollection(schema)) {
-                const resource = await this.createCollectionSource(name, schema);
-                document.resources.set(name, resource);
-                continue;
-            }
-            if (index_js_1.OpraSchema.isSingleton(schema)) {
-                const resource = await this.createSingletonSource(name, schema);
-                document.resources.set(name, resource);
-                continue;
-            }
-            if (index_js_1.OpraSchema.isStorage(schema)) {
-                const resource = await this.createFileSource(name, schema);
-                document.resources.set(name, resource);
-                continue;
-            }
-        }
-        catch (e) {
-            e.message = `Error in Resource schema (${name}): ` + e.message;
-            throw e;
-        }
-        throw new TypeError(`Invalid Resource schema: ${JSON.stringify(schema).substring(0, 20)}...`);
-    }
-}
-exports.processSourceQueue = processSourceQueue;
-async function createCollectionResource(name, schema) {
-    const { document } = this;
-    const dataType = document.getComplexType(schema.type);
-    const initArgs = {
-        ...schema,
-        name,
-        type: dataType
-    };
-    return new collection_js_1.Collection(document, initArgs);
-}
-exports.createCollectionResource = createCollectionResource;
-async function createSingletonResource(name, schema) {
-    const { document } = this;
-    const dataType = document.getComplexType(schema.type);
-    const initArgs = {
-        ...schema,
-        name,
-        type: dataType
-    };
-    return new singleton_js_1.Singleton(document, initArgs);
-}
-exports.createSingletonResource = createSingletonResource;
-async function createStorageResource(name, schema) {
-    const { document } = this;
-    const initArgs = {
-        ...schema,
-        name
-    };
-    return new storage_js_1.Storage(document, initArgs);
-}
-exports.createStorageResource = createStorageResource;

package/cjs/document/factory/process-types.js

@@ -1,191 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addDataType = exports.createDataTypeInstance = exports.processTypes = void 0;
-const index_js_1 = require("../../schema/index.js");
-const complex_type_js_1 = require("../data-type/complex-type.js");
-const enum_type_js_1 = require("../data-type/enum-type.js");
-const mapped_type_js_1 = require("../data-type/mapped-type.js");
-const simple_type_js_1 = require("../data-type/simple-type.js");
-const union_type_js_1 = require("../data-type/union-type.js");
-async function processTypes() {
-    const { document, typeQueue } = this;
-    // Create DataType instances
-    for (const [name, schema] of typeQueue.entries()) {
-        const dataType = this.createDataTypeInstance(schema.kind, name);
-        document.types.set(name, dataType);
-    }
-    // Process schemas
-    const typeNames = Array.from(typeQueue.keys());
-    for (const name of typeNames) {
-        if (!typeQueue.has(name))
-            continue;
-        this.addDataType(name);
-    }
-    document.invalidate();
-}
-exports.processTypes = processTypes;
-function createDataTypeInstance(kind, name) {
-    const dataType = {
-        document: this.document,
-        kind,
-        name
-    };
-    switch (kind) {
-        case index_js_1.OpraSchema.ComplexType.Kind:
-            Object.setPrototypeOf(dataType, complex_type_js_1.ComplexType.prototype);
-            break;
-        case index_js_1.OpraSchema.EnumType.Kind:
-            Object.setPrototypeOf(dataType, enum_type_js_1.EnumType.prototype);
-            break;
-        case index_js_1.OpraSchema.MappedType.Kind:
-            Object.setPrototypeOf(dataType, mapped_type_js_1.MappedType.prototype);
-            break;
-        case index_js_1.OpraSchema.SimpleType.Kind:
-            Object.setPrototypeOf(dataType, simple_type_js_1.SimpleType.prototype);
-            break;
-        case index_js_1.OpraSchema.UnionType.Kind:
-            Object.setPrototypeOf(dataType, union_type_js_1.UnionType.prototype);
-            break;
-        default:
-            throw new TypeError(`Unknown DataType kind (${kind})`);
-    }
-    return dataType;
-}
-exports.createDataTypeInstance = createDataTypeInstance;
-function addDataType(schemaOrName) {
-    const { document, typeQueue, circularRefs, curPath } = this;
-    const name = typeof schemaOrName === 'string' ? schemaOrName : undefined;
-    let schema;
-    let dataType;
-    if (name) {
-        // Check if data type exists in document
-        dataType = document.getDataType(name);
-        // Get schema from stack, it is already done if not exist
-        schema = typeQueue.get(name);
-        if (!schema)
-            return dataType;
-        // Detect circular refs
-        if (circularRefs.has(name))
-            throw new TypeError(`Circular reference detected. ${[...Array.from(circularRefs.keys()), name].join('>')}`);
-        circularRefs.set(name, 1);
-    }
-    else
-        schema = schemaOrName;
-    try {
-        // Init base
-        let base;
-        if ((index_js_1.OpraSchema.isSimpleType(schema) || index_js_1.OpraSchema.isComplexType(schema) || index_js_1.OpraSchema.isEnumType(schema)) && schema.base) {
-            curPath.push(typeof schema.base === 'string' ? schema.base : '[base]');
-            base = this.addDataType(schema.base);
-            curPath.pop();
-        }
-        // **** Init SimpleType ****
-        if (index_js_1.OpraSchema.isSimpleType(schema)) {
-            const initArgs = {
-                ...schema,
-                name,
-                base
-            };
-            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-            if (name)
-                curPath.push(name);
-            simple_type_js_1.SimpleType.apply(dataType, [document, initArgs]);
-            if (name)
-                curPath.pop();
-            return dataType;
-        }
-        // **** Init ComplexType ****
-        if (index_js_1.OpraSchema.isComplexType(schema)) {
-            const initArgs = {
-                ...schema,
-                name,
-                base
-            };
-            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-            if (name)
-                curPath.push(name);
-            complex_type_js_1.ComplexType.apply(dataType, [document, initArgs]);
-            if (name)
-                typeQueue.delete(name);
-            // process fields
-            if (schema.fields) {
-                for (const [elemName, v] of Object.entries(schema.fields)) {
-                    const elemSchema = typeof v === 'object' ? v : { type: v };
-                    curPath.push(`${name}.${elemName}[type]`);
-                    const elemType = this.addDataType(elemSchema.type);
-                    dataType.addField({
-                        ...elemSchema,
-                        name: elemName,
-                        type: elemType
-                    });
-                    curPath.pop();
-                }
-            }
-            if (name)
-                curPath.pop();
-            return dataType;
-        }
-        // **** Init EnumType ****
-        if (index_js_1.OpraSchema.isEnumType(schema)) {
-            const initArgs = {
-                ...schema,
-                name,
-                base
-            };
-            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-            if (name)
-                curPath.push(name);
-            enum_type_js_1.EnumType.apply(dataType, [document, initArgs]);
-            if (name)
-                curPath.pop();
-            return dataType;
-        }
-        // **** Init UnionType ****
-        if (index_js_1.OpraSchema.isUnionType(schema)) {
-            const unionTypes = schema.types.map(t => this.addDataType(t));
-            const initArgs = {
-                ...schema,
-                name,
-                types: unionTypes
-            };
-            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-            if (name)
-                curPath.push(name);
-            union_type_js_1.UnionType.apply(dataType, [document, initArgs]);
-            if (name)
-                curPath.pop();
-            return dataType;
-        }
-        // **** Init MappedType ****
-        if (index_js_1.OpraSchema.isMappedType(schema)) {
-            const dt = this.addDataType(schema.type);
-            if (!(dt instanceof complex_type_js_1.ComplexType))
-                throw new TypeError(`MappedType requires a ComplexType`);
-            const initArgs = {
-                ...schema,
-                name,
-                type: dt
-            };
-            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-            if (name)
-                curPath.push(name);
-            mapped_type_js_1.MappedType.apply(dataType, [document, initArgs]);
-            if (name)
-                curPath.pop();
-            return dataType;
-        }
-    }
-    catch (e) {
-        if (curPath.length)
-            e.message = `Error at ${curPath.join('/')}: ` + e.message;
-        throw e;
-    }
-    finally {
-        if (name) {
-            circularRefs.delete(name);
-            typeQueue.delete(name);
-        }
-    }
-    throw new TypeError(`Invalid DataType schema: ${JSON.stringify(schema).substring(0, 20)}...`);
-}
-exports.addDataType = addDataType;

package/cjs/document/utils/generate-codec.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._generateCodec = exports.generateCodec = void 0;
-const tslib_1 = require("tslib");
-const vg = tslib_1.__importStar(require("valgen"));
-const complex_type_js_1 = require("../data-type/complex-type.js");
-const enum_type_js_1 = require("../data-type/enum-type.js");
-const mapped_type_js_1 = require("../data-type/mapped-type.js");
-const simple_type_js_1 = require("../data-type/simple-type.js");
-const union_type_js_1 = require("../data-type/union-type.js");
-function generateCodec(type, codec, options) {
-    return _generateCodec(type, codec, options);
-}
-exports.generateCodec = generateCodec;
-function _generateCodec(type, codec, options) {
-    const schema = {};
-    for (const f of type.fields.values()) {
-        let fn;
-        if (f.type instanceof simple_type_js_1.SimpleType || f.type instanceof enum_type_js_1.EnumType) {
-            fn = f.type[codec];
-        }
-        else if (f.type instanceof complex_type_js_1.ComplexType || f.type instanceof mapped_type_js_1.MappedType || f.type instanceof union_type_js_1.UnionType) {
-            fn = _generateCodec(f.type, codec, options);
-        }
-        /* istanbul ignore next */
-        if (!fn)
-            throw new TypeError(`Can't generate codec for (${f.type})`);
-        if (f.isArray)
-            fn = vg.isArray(fn);
-        schema[f.name] = !options.partial && f.required ? vg.required(fn) : vg.optional(fn);
-    }
-    return vg.isObject(schema, {
-        ctor: type.ctor,
-        additionalFields: type.additionalFields ?? false,
-        name: type.name,
-        caseInSensitive: true,
-    });
-}
-exports._generateCodec = _generateCodec;

package/esm/document/decorators/build-operation-decorator.js

@@ -1,23 +0,0 @@
-import 'reflect-metadata';
-import { RESOURCE_METADATA } from '../constants.js';
-export function buildOperationDecorator(operation) {
-    return (options) => {
-        const mergeMetadata = {};
-        const decorator = ((target, propertyKey) => {
-            if (propertyKey !== operation)
-                throw new TypeError(`Name of the handler name should be '${operation}'`);
-            const operationMeta = { ...options };
-            const resourceMetadata = (Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {});
-            resourceMetadata.operations = resourceMetadata.operations || {};
-            resourceMetadata.operations[operation] = operationMeta;
-            Object.assign(operationMeta, mergeMetadata);
-            Reflect.defineMetadata(RESOURCE_METADATA, resourceMetadata, target.constructor);
-        });
-        decorator.Parameter = (name) => {
-            mergeMetadata.parameters = mergeMetadata.parameters || {};
-            mergeMetadata.parameters[name] = {};
-            return decorator;
-        };
-        return decorator;
-    };
-}

package/esm/document/decorators/collection-decorator.js

@@ -1,26 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import { buildOperationDecorator } from './build-operation-decorator.js';
-import { ResourceDecorator } from './resource.decorator.js';
-const operationProperties = ['create', 'delete', 'deleteMany', 'get', 'findMany', 'update', 'updateMany'];
-export function CollectionDecorator(type, options) {
-    return ResourceDecorator(OpraSchema.Collection.Kind, { ...options, type });
-}
-const operationDecorators = {
-    Create: buildOperationDecorator('create'),
-    Delete: buildOperationDecorator('delete'),
-    DeleteMany: buildOperationDecorator('deleteMany'),
-    Get: buildOperationDecorator('get'),
-    FindMany: buildOperationDecorator('findMany'),
-    Update: buildOperationDecorator('update'),
-    UpdateMany: buildOperationDecorator('updateMany')
-};
-Object.assign(CollectionDecorator, ResourceDecorator);
-Object.assign(CollectionDecorator, operationDecorators);
-CollectionDecorator.Action = function (options) {
-    const oldDecorator = ResourceDecorator.Action(options);
-    return (target, propertyKey) => {
-        if (typeof propertyKey === 'string' && operationProperties.includes(propertyKey))
-            throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
-        return oldDecorator(target, propertyKey);
-    };
-};

package/esm/document/decorators/resource.decorator.js

@@ -1,33 +0,0 @@
-import omit from 'lodash.omit';
-import merge from 'putil-merge';
-import { RESOURCE_METADATA } from '../constants.js';
-export function ResourceDecorator(kind, options) {
-    const namePattern = new RegExp(`^(.*)(${kind}|Resource|Controller)$`);
-    return function (target) {
-        const name = options?.name || namePattern.exec(target.name)?.[1] || target.name;
-        const metadata = { kind, name };
-        const baseMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, Object.getPrototypeOf(target));
-        if (baseMetadata)
-            merge(metadata, baseMetadata, { deep: true });
-        const oldMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target);
-        if (oldMetadata)
-            merge(metadata, oldMetadata, { deep: true });
-        merge(metadata, {
-            kind,
-            name,
-            ...omit(options, ['kind', 'name', 'controller'])
-        }, { deep: true });
-        Reflect.defineMetadata(RESOURCE_METADATA, metadata, target);
-    };
-}
-ResourceDecorator.Action = function (options) {
-    return (target, propertyKey) => {
-        if (typeof propertyKey !== 'string')
-            throw new TypeError(`This decorator can't be used for Symbol keys'`);
-        const actionMeta = { ...options };
-        const resourceMetadata = (Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {});
-        resourceMetadata.actions = resourceMetadata.actions || {};
-        resourceMetadata.actions[propertyKey] = actionMeta;
-        Reflect.defineMetadata(RESOURCE_METADATA, resourceMetadata, target.constructor);
-    };
-};

package/esm/document/decorators/singleton.decorator.js

@@ -1,21 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import { buildOperationDecorator } from './build-operation-decorator.js';
-import { ResourceDecorator } from './resource.decorator.js';
-const operationProperties = ['create', 'delete', 'get', 'update'];
-export function SingletonDecorator(type, options) {
-    return ResourceDecorator(OpraSchema.Singleton.Kind, { ...options, type });
-}
-Object.assign(SingletonDecorator, ResourceDecorator);
-SingletonDecorator.Create = buildOperationDecorator('create');
-SingletonDecorator.Get = buildOperationDecorator('get');
-SingletonDecorator.Delete = buildOperationDecorator('delete');
-SingletonDecorator.Update = buildOperationDecorator('update');
-SingletonDecorator.Action = function (options) {
-    const oldDecorator = ResourceDecorator.Action(options);
-    const operators = ['create', 'delete', 'get', 'update'];
-    return (target, propertyKey) => {
-        if (typeof propertyKey === 'string' && operators.includes(propertyKey))
-            throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
-        return oldDecorator(target, propertyKey);
-    };
-};

package/esm/document/decorators/storage.decorator.js

@@ -1,23 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import { buildOperationDecorator } from './build-operation-decorator.js';
-import { ResourceDecorator } from './resource.decorator.js';
-const operationProperties = ['delete', 'get', 'post'];
-export function StorageDecorator(options) {
-    return ResourceDecorator(OpraSchema.Storage.Kind, options);
-}
-const operationDecorators = {
-    Delete: buildOperationDecorator('delete'),
-    Get: buildOperationDecorator('get'),
-    Post: buildOperationDecorator('post')
-};
-Object.assign(StorageDecorator, ResourceDecorator);
-Object.assign(StorageDecorator, operationDecorators);
-StorageDecorator.Action = function (options) {
-    const oldDecorator = ResourceDecorator.Action(options);
-    const operators = ['delete', 'get', 'post'];
-    return (target, propertyKey) => {
-        if (typeof propertyKey === 'string' && operators.includes(propertyKey))
-            throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
-        return oldDecorator(target, propertyKey);
-    };
-};

package/esm/document/factory/add-references.js

@@ -1,16 +0,0 @@
-import { ApiDocument } from '../api-document.js';
-export async function addReferences(references) {
-    const { document } = this;
-    for (const [ns, r] of Object.entries(references)) {
-        if (typeof r === 'string') {
-            document.references.set(ns, await this.createDocumentFromUrl(r));
-        }
-        else if (r instanceof ApiDocument)
-            document.references.set(ns, r);
-        else if (typeof r === 'object') {
-            document.references.set(ns, await this.createDocument(r));
-        }
-        else
-            throw new TypeError(`Invalid document reference (${ns}) in schema`);
-    }
-}