@opra/core 0.0.13 → 0.1.0

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

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityResourceHandler = void 0;
-const tslib_1 = require("tslib");
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const i18n_1 = require("@opra/i18n");
-const index_js_1 = require("../../exception/index.js");
-const query_interface_js_1 = require("../../interfaces/query.interface.js");
-const complex_type_js_1 = require("../data-type/complex-type.js");
-const entity_type_js_1 = require("../data-type/entity-type.js");
-const resource_handler_js_1 = require("./resource-handler.js");
-class EntityResourceHandler extends resource_handler_js_1.ResourceHandler {
-    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`);
-    }
-    async execute(ctx) {
-        const { query } = ctx;
-        if (query_interface_js_1.OpraQuery.isSearchQuery(query)) {
-            const promises = [];
-            let search;
-            let count;
-            promises.push(this._executeFn(ctx, query.queryType)
-                .then(v => search = v));
-            if (query.count) {
-                promises.push(this._executeFn(ctx, 'count')
-                    .then(v => count = v));
-            }
-            await Promise.all(promises);
-            ctx.response.value = {
-                ...search,
-                ...count
-            };
-            return;
-        }
-        ctx.response.value = await this._executeFn(ctx, query.queryType);
-    }
-    async _executeFn(ctx, queryType) {
-        const resolverInfo = this._args.resolvers?.[queryType];
-        if (resolverInfo.forbidden || !resolverInfo.handler)
-            throw new index_js_1.ForbiddenError({
-                message: (0, i18n_1.translate)('RESOLVER_FORBIDDEN', { queryType }),
-                severity: 'error',
-                code: 'RESOLVER_FORBIDDEN'
-            });
-        let result = await resolverInfo.handler(ctx);
-        switch (queryType) {
-            case 'search':
-                return {
-                    '@opra:metadata': '/$metadata/types/' + this.dataType.name,
-                    items: Array.isArray(result) ? result : (ctx.response.value ? [result] : [])
-                };
-            case 'get':
-            case 'update':
-                if (!result) {
-                    const query = ctx.query;
-                    throw new index_js_1.ResourceNotFoundError(this.name, query.keyValue);
-                }
-                break;
-            case 'count':
-                return { count: result || 0 };
-            case 'delete':
-            case 'deleteMany':
-            case 'updateMany':
-                let affectedRecords;
-                if (typeof result === 'number')
-                    affectedRecords = result;
-                if (typeof result === 'boolean')
-                    affectedRecords = result ? 1 : 0;
-                if (typeof result === 'object')
-                    affectedRecords = result.affectedRows || result.affectedRecords;
-                return { affectedRecords };
-        }
-        if (!result)
-            return;
-        result = Array.isArray(result) ? result[0] : result;
-        let dataType = this.dataType;
-        if (ctx.resultPath) {
-            const pathArray = ctx.resultPath.split('.');
-            for (const property of pathArray) {
-                const prop = dataType instanceof complex_type_js_1.ComplexType ? dataType.properties?.[property] : undefined;
-                dataType = prop && prop.type ? this.service.types[prop.type || 'string'] : undefined;
-                result = result && typeof result === 'object' && result[property];
-            }
-        }
-        if (queryType === 'create')
-            ctx.response.status = 201;
-        return {
-            '@opra:metadata': dataType ? '/$metadata/types/' + dataType.name : '__unknown__',
-            ...result
-        };
-    }
-}
-exports.EntityResourceHandler = EntityResourceHandler;

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

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceHandler = void 0;
-const tslib_1 = require("tslib");
-const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
-const terminal_utils_js_1 = require("../../utils/terminal-utils.js");
-class ResourceHandler {
-    _args;
-    path;
-    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}]`;
-    }
-    async prepare(ctx) {
-        const { query } = ctx;
-        const fn = this._args['pre_' + query.queryType];
-        if (fn && typeof fn === 'function') {
-            await fn(ctx);
-        }
-    }
-    getMetadata() {
-        return (0, putil_merge_1.default)({}, {
-            ...this._args,
-            instance: undefined,
-        }, {
-            deep: true,
-            filter: (source, key) => {
-                return (key !== 'instance' && typeof source[key] !== 'function' && source[key] != null);
-            }
-        });
-    }
-    [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.ResourceHandler = ResourceHandler;

package/cjs/implementation/schema-generator.js

@@ -1,184 +0,0 @@
-"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', 'count', 'create', 'get', 'update', 'updateMany', 'delete', 'deleteMany'];
-class SchemaGenerator {
-    _dataTypes = {};
-    _resources = {};
-    constructor() {
-        //
-    }
-    async addDataType(thunk) {
-        thunk = (0, types_1.isPromise)(thunk) ? await thunk : thunk;
-        if (typeof thunk === 'function') {
-            if (!(0, class_utils_js_1.isConstructor)(thunk))
-                return this.addDataType(await thunk());
-            if (internal_data_types_js_1.builtinClassMap.has(thunk))
-                return this.addDataType(internal_data_types_js_1.builtinClassMap.get(thunk));
-            const ctor = thunk;
-            const metadata = Reflect.getOwnMetadata(schema_1.DATATYPE_METADATA, ctor);
-            if (!metadata)
-                throw new TypeError(`Class "${ctor}" has no type metadata`);
-            // 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;
-            }
-            const 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 = p.type || 'string';
-                    if (typeof type !== 'string') {
-                        const propSchema = await this.addDataType(type);
-                        type = propSchema.name;
-                    }
-                    else {
-                        if (internal_data_types_js_1.internalDataTypes.has(type))
-                            await this.addDataType(internal_data_types_js_1.internalDataTypes.get(type));
-                    }
-                    schema.properties = schema.properties || {};
-                    schema.properties[k] = { ...p, type };
-                }
-            }
-            return this.addDataType(schema);
-        }
-        if (!schema_1.OpraSchema.isDataType(thunk))
-            throw new TypeError(`Invalid data type schema`);
-        // Check if datatype previously added
-        const currentSchema = this._dataTypes[thunk.name];
-        if (currentSchema) {
-            if (!(currentSchema.kind === thunk.kind && currentSchema.ctor && currentSchema.ctor === thunk.ctor))
-                throw new Error(`An other instance of "${currentSchema.name}" data type previously defined`);
-            return currentSchema;
-        }
-        if (schema_1.OpraSchema.isSimpleType(thunk) && !internal_data_types_js_1.primitiveDataTypeNames.includes(thunk.type))
-            throw new Error(`"type" of SimpleType schema must be one of enumerated value (${internal_data_types_js_1.primitiveDataTypeNames})`);
-        return this._dataTypes[thunk.name] = {
-            ...thunk
-        };
-    }
-    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,
-                instance,
-                resolvers: {}
-            };
-            if (schema_1.OpraSchema.isEntityResource(resourceSchema)) {
-                for (const methodName of entityMethods) {
-                    let fn = instance[methodName];
-                    if (typeof fn === 'function') {
-                        const info = resourceSchema.resolvers[methodName] = {
-                            ...Reflect.getMetadata(constants_js_1.RESOLVER_METADATA, proto, methodName)
-                        };
-                        if (!info.forbidden) {
-                            info.handler = fn.bind(instance);
-                            fn = instance['pre_' + methodName];
-                            if (typeof fn === 'function')
-                                resourceSchema['pre_' + methodName] = fn.bind(instance);
-                        }
-                    }
-                    else
-                        resourceSchema.resolvers[methodName] = { forbidden: true };
-                }
-            }
-        }
-        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)
-            .map(name => generator._dataTypes[name])
-            .sort((a, b) => {
-            if (a.kind !== b.kind) {
-                if (a.kind === 'SimpleType')
-                    return -1;
-                if (b.kind === 'SimpleType')
-                    return 1;
-                if (a.kind === 'ComplexType')
-                    return -1;
-                if (b.kind === 'ComplexType')
-                    return 1;
-            }
-            return (a.name < b.name ? -1 : 1);
-        });
-        const resources = Object.keys(generator._resources).sort()
-            .map(name => generator._resources[name]);
-        return {
-            version: '1',
-            ...args,
-            types,
-            resources
-        };
-    }
-}
-exports.SchemaGenerator = SchemaGenerator;

package/cjs/interfaces/metadata/api-resolver.metadata.js

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

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

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/*
-export type ResourceReadOperationMetadata = StrictOmit<OpraSchema.ResourceReadOperation, 'handler'>;
-export type ResourceSearchOperationMetadata = StrictOmit<OpraSchema.ResourceSearchOperation, 'handler'>;
-export type ResourceCreateOperationMetadata = StrictOmit<OpraSchema.ResourceCreateOperation, 'handler'>;
-export type ResourceUpdateOperationMetadata = StrictOmit<OpraSchema.ResourceUpdateOperation, 'handler'>;
-export type ResourcePatchOperationMetadata = StrictOmit<OpraSchema.ResourcePatchOperation, 'handler'>;
-export type ResourceDeleteOperationMetadata = StrictOmit<OpraSchema.ResourceDeleteOperation, 'handler'>;
-export type ResourceExecuteOperationMetadata = StrictOmit<OpraSchema.ResourceExecuteOperation, 'handler'>;
-*/

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

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

package/cjs/utils/class-utils.js

@@ -1,37 +0,0 @@
-"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;

package/cjs/utils/headers.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Headers = void 0;
-const index_js_1 = require("../enums/index.js");
-const wellKnownHeaders = Object.values(index_js_1.HttpHeaders)
-    .reduce((target, k) => {
-    target[k.toLowerCase()] = k;
-    return target;
-}, {});
-const wrapKey = (prop) => {
-    return typeof prop == 'string' ? wellKnownHeaders[prop.toLowerCase()] || prop : prop;
-};
-/**
- * Create a proxy that ensures header keys are always formatted according to well known header names
- */
-var Headers;
-(function (Headers) {
-    function from(obj) {
-        const headers = create();
-        for (const [k, v] of Object.entries(obj))
-            headers[k] = v;
-        return headers;
-    }
-    Headers.from = from;
-    function create() {
-        return new Proxy({}, {
-            set: (target, prop, value, receiver) => {
-                let key = prop;
-                if (typeof key === 'string')
-                    key = wellKnownHeaders[key.toLowerCase()] || key;
-                const result = Reflect.set(target, key, value, receiver);
-                /*  istanbul ignore next */
-                if (!result && Object.isFrozen(target))
-                    throw new TypeError('Cannot add property, object is not extensible');
-                return result;
-            },
-            get: (target, prop, receiver) => {
-                return Reflect.get(target, wrapKey(prop), receiver);
-            },
-            deleteProperty: (target, prop) => {
-                return Reflect.deleteProperty(target, wrapKey(prop));
-            },
-            defineProperty: (target, prop, descriptor) => {
-                let key = prop;
-                if (typeof key === 'string')
-                    key = wellKnownHeaders[key.toLowerCase()] || key;
-                return Reflect.defineProperty(target, key, descriptor);
-            },
-            getOwnPropertyDescriptor: (target, prop) => {
-                return Reflect.getOwnPropertyDescriptor(target, wrapKey(prop));
-            },
-            has: (target, prop) => {
-                return Reflect.has(target, wrapKey(prop));
-            }
-        });
-    }
-    Headers.create = create;
-})(Headers = exports.Headers || (exports.Headers = {}));

package/cjs/utils/internal-data-types.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.internalDataTypes = exports.builtinClassMap = exports.primitiveDataTypeNames = void 0;
-exports.primitiveDataTypeNames = ['boolean', 'number', 'string', 'null'];
-exports.builtinClassMap = new Map();
-exports.internalDataTypes = new Map();
-const internalDataTypeArray = [
-    {
-        kind: 'SimpleType',
-        name: 'boolean',
-        type: 'boolean',
-        description: 'Simple true/false value',
-        ctor: Boolean
-    },
-    {
-        kind: 'SimpleType',
-        name: 'string',
-        type: 'string',
-        description: 'A sequence of characters',
-        ctor: String
-    },
-    {
-        kind: 'SimpleType',
-        name: 'number',
-        type: 'number',
-        description: 'Both Integer as well as Floating-Point numbers',
-        ctor: Number
-    },
-    {
-        kind: 'SimpleType',
-        name: 'integer',
-        type: 'number',
-        base: 'number',
-        description: 'Integer number',
-        ctor: Number
-    },
-    {
-        kind: 'ComplexType',
-        name: 'object',
-        description: 'Object type with additional properties',
-        additionalProperties: true,
-        ctor: Object
-    },
-    {
-        kind: 'SimpleType',
-        name: 'date',
-        type: 'string',
-        description: 'Date',
-        format: 'date',
-        ctor: Date
-    },
-    {
-        kind: 'SimpleType',
-        name: 'date-time',
-        type: 'string',
-        description: 'Date time value',
-        format: 'date-time',
-        ctor: Date
-    },
-    {
-        kind: 'SimpleType',
-        name: 'time',
-        type: 'string',
-        description: 'Time value',
-        format: 'time',
-        ctor: String
-    },
-    {
-        kind: 'SimpleType',
-        name: 'buffer',
-        type: 'string',
-        description: 'Buffer value',
-        format: 'base64',
-        ctor: Buffer
-    }
-];
-internalDataTypeArray.forEach(sch => {
-    exports.internalDataTypes.set(sch.name, sch);
-    if (sch.ctor && !exports.builtinClassMap.has(sch.ctor))
-        exports.builtinClassMap.set(sch.ctor, sch);
-});

package/cjs/utils/responsive-object.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Responsive = void 0;
-function Responsive(wrapped) {
-    wrapped = wrapped || {};
-    const keyMap = {};
-    Object.keys(wrapped).forEach(k => keyMap[k.toLowerCase()] = k);
-    const wrapKey = (prop) => {
-        return typeof prop == 'string' ? keyMap[prop.toLowerCase()] : prop;
-    };
-    return new Proxy(wrapped, {
-        set: (target, prop, value, receiver) => {
-            let key = prop;
-            if (typeof key === 'string') {
-                const keyLower = key.toLowerCase();
-                key = keyMap[keyLower] = keyMap[keyLower] || key;
-            }
-            const result = Reflect.set(target, key, value, receiver);
-            if (!result && Object.isFrozen(target))
-                throw new TypeError('Cannot add property, object is not extensible');
-            return result;
-        },
-        get: (target, prop, receiver) => {
-            return Reflect.get(target, wrapKey(prop), receiver);
-        },
-        deleteProperty: (target, prop) => {
-            const key = wrapKey(prop);
-            if (typeof prop === 'string') {
-                delete keyMap[prop.toLowerCase()];
-            }
-            return Reflect.deleteProperty(target, key);
-        },
-        defineProperty: (target, prop, descriptor) => {
-            let key = prop;
-            if (typeof key === 'string') {
-                const keyLower = key.toLowerCase();
-                key = keyMap[keyLower] = keyMap[keyLower] || key;
-            }
-            return Reflect.defineProperty(target, key, descriptor);
-        },
-        getOwnPropertyDescriptor: (target, prop) => {
-            return Reflect.getOwnPropertyDescriptor(target, wrapKey(prop));
-        },
-        has: (target, prop) => {
-            return Reflect.has(target, wrapKey(prop));
-        }
-    });
-}
-exports.Responsive = Responsive;

package/cjs/utils/terminal-utils.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.colorFgMagenta = exports.colorFgYellow = exports.colorReset = exports.nodeInspectCustom = void 0;
-exports.nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
-exports.colorReset = "\x1b[0m";
-exports.colorFgYellow = "\x1b[33m";
-exports.colorFgMagenta = "\x1b[35m";

package/esm/constants.d.ts

@@ -1,3 +0,0 @@
-export declare const OpraVersion = "1.0";
-export declare const RESOURCE_METADATA = "opra:resource.metadata";
-export declare const RESOLVER_METADATA = "opra:resolver.metadata";

package/esm/constants.js

@@ -1,3 +0,0 @@
-export const OpraVersion = '1.0';
-export const RESOURCE_METADATA = 'opra:resource.metadata';
-export const RESOLVER_METADATA = 'opra:resolver.metadata';

package/esm/decorators/api-entity-resource.decorator.d.ts

@@ -1,5 +0,0 @@
-import "reflect-metadata";
-import { EntityResourceMetadata } from '../interfaces/metadata/opra-schema.metadata.js';
-import { TypeThunkAsync } from '../types.js';
-export declare type EntityResourceOptions = Pick<EntityResourceMetadata, 'name' | 'description'> & {};
-export declare function ApiEntityResource(entityFunc: TypeThunkAsync, options?: EntityResourceOptions): (target: Function) => void;

package/esm/decorators/api-entity-resource.decorator.js

@@ -1,19 +0,0 @@
-import "reflect-metadata";
-import _ from 'lodash';
-import { RESOURCE_METADATA } from '../constants.js';
-const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
-const NAME_PATTERN = /^(.*)Resource$/;
-export function ApiEntityResource(entityFunc, options) {
-    return function (target) {
-        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
-        const meta = {
-            kind: 'EntityResource',
-            type: entityFunc,
-            name
-        };
-        Object.assign(meta, _.omit(options, Object.keys(meta)));
-        Reflect.defineMetadata(RESOURCE_METADATA, meta, target);
-        /* Define Injectable metadata for NestJS support*/
-        Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
-    };
-}

package/esm/decorators/api-resolver.decorator.d.ts

@@ -1,2 +0,0 @@
-import { ApiResolverMetadata } from '../interfaces/metadata/api-resolver.metadata.js';
-export declare function ApiResolver(options?: ApiResolverMetadata): PropertyDecorator;

package/esm/decorators/api-resolver.decorator.js

@@ -1,9 +0,0 @@
-import { RESOLVER_METADATA } from '../constants.js';
-export function ApiResolver(options) {
-    return (target, propertyKey) => {
-        const metadata = {
-            ...options
-        };
-        Reflect.defineMetadata(RESOLVER_METADATA, metadata, target, propertyKey);
-    };
-}

package/esm/implementation/data-type/complex-type.d.ts

@@ -1,19 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import { ResponsiveObject } from '../../utils/responsive-object.js';
-import { nodeInspectCustom } from '../../utils/terminal-utils.js';
-import type { OpraDocument } from '../opra-document.js';
-import { DataType } from './data-type.js';
-export declare type ComplexTypeArgs = StrictOmit<OpraSchema.ComplexType, 'kind'>;
-export declare class ComplexType extends DataType {
-    protected readonly _args: StrictOmit<ComplexTypeArgs, 'properties'>;
-    readonly ownProperties?: ResponsiveObject<OpraSchema.Property>;
-    readonly properties?: ResponsiveObject<OpraSchema.Property>;
-    constructor(owner: OpraDocument, args: ComplexTypeArgs, base?: ComplexType);
-    get abstract(): boolean;
-    get additionalProperties(): boolean | string | Pick<OpraSchema.Property, 'type' | 'format' | 'isArray' | 'enum'> | undefined;
-    getProperty(name: string): OpraSchema.Property;
-    getMetadata(): OpraSchema.ComplexTypeMetadata;
-    toString(): string;
-    [nodeInspectCustom](): string;
-}