@opra/core 0.0.13 → 0.1.1

package/esm/implementation/data-type/complex-type.js

@@ -1,48 +0,0 @@
-import merge from 'putil-merge';
-import { Responsive } from '../../utils/responsive-object.js';
-import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../../utils/terminal-utils.js';
-import { DataType } from './data-type.js';
-export class ComplexType extends DataType {
-    ownProperties;
-    properties;
-    constructor(owner, args, base) {
-        super(owner, {
-            kind: 'ComplexType',
-            ...args
-        }, base);
-        this.ownProperties = args?.properties && Responsive(args.properties);
-        this.properties = (base?.properties || this.ownProperties) &&
-            Responsive({ ...base?.properties, ...this.ownProperties });
-    }
-    get abstract() {
-        return !!this._args.abstract;
-    }
-    get additionalProperties() {
-        return this._args.additionalProperties;
-    }
-    getProperty(name) {
-        const t = this.properties?.[name];
-        if (!t)
-            throw new Error(`"${this.name}" type has no property named "${name}"`);
-        return t;
-    }
-    getMetadata() {
-        const out = super.getMetadata();
-        if (this.additionalProperties)
-            out.additionalProperties = this.additionalProperties;
-        if (this.ownProperties) {
-            out.properties = {};
-            for (const [k, prop] of Object.entries(this.ownProperties)) {
-                out.properties[k] = merge({}, prop, { deep: true });
-            }
-        }
-        return out;
-    }
-    toString() {
-        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
-    }
-    [nodeInspectCustom]() {
-        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
-            ` ${colorFgMagenta + this.name + colorReset}]`;
-    }
-}

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

@@ -1,17 +0,0 @@
-import { Type } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import type { OpraDocument } from '../opra-document.js';
-export declare abstract class DataType {
-    protected _owner: OpraDocument;
-    protected readonly _args: any;
-    readonly base?: DataType;
-    protected constructor(owner: OpraDocument, args: OpraSchema.DataType, base?: DataType);
-    get owner(): OpraDocument;
-    get kind(): OpraSchema.DataTypeKind;
-    get name(): string;
-    get description(): string | undefined;
-    get abstract(): boolean;
-    get ctor(): Type;
-    is(typeName: string): boolean;
-    getMetadata(): any;
-}

package/esm/implementation/data-type/data-type.js

@@ -1,43 +0,0 @@
-export class DataType {
-    _owner;
-    _args;
-    base;
-    constructor(owner, args, base) {
-        this._args = { ...args };
-        this._owner = owner;
-        if (base) {
-            this.base = base;
-            Object.setPrototypeOf(this._args, base._args);
-        }
-    }
-    get owner() {
-        return this._owner;
-    }
-    get kind() {
-        return this._args.kind;
-    }
-    get name() {
-        return this._args.name;
-    }
-    get description() {
-        return this._args.description;
-    }
-    get abstract() {
-        return !!this._args.abstract;
-    }
-    get ctor() {
-        return this._args.ctor;
-    }
-    is(typeName) {
-        return this.name === typeName || !!(this.base && this.base.is(typeName));
-    }
-    getMetadata() {
-        return {
-            kind: this.kind,
-            base: this.base?.name,
-            abstract: this.abstract ? true : undefined,
-            name: this.name,
-            description: this.description,
-        };
-    }
-}

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

@@ -1,10 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import { OpraDocument } from '../opra-document.js';
-import { ComplexType } from './complex-type.js';
-export declare type EntityTypeArgs = StrictOmit<OpraSchema.EntityType, 'kind'>;
-export declare class EntityType extends ComplexType {
-    protected readonly _args: StrictOmit<EntityTypeArgs, 'properties'>;
-    constructor(owner: OpraDocument, args: EntityTypeArgs, base?: ComplexType | EntityType);
-    get primaryKey(): string;
-}

package/esm/implementation/data-type/entity-type.js

@@ -1,29 +0,0 @@
-import * as Optionals from '@opra/optionals';
-import { ComplexType } from './complex-type.js';
-export class EntityType extends ComplexType {
-    constructor(owner, args, base) {
-        super(owner, {
-            ...args
-        }, base);
-        this._args.kind = 'EntityType';
-        // Try to determine primary key info from SQB
-        if (Optionals.SqbConnect && args.ctor) {
-            const sqbEntity = Optionals.SqbConnect.EntityMetadata.get(args.ctor);
-            if (sqbEntity?.indexes) {
-                const primaryIndex = sqbEntity.indexes.find(x => x.primary);
-                if (primaryIndex) {
-                    if (primaryIndex.columns.length > 1)
-                        throw new TypeError(`Multi-key indexes is not implemented yet`);
-                    this._args.primaryKey = primaryIndex.columns[0];
-                }
-            }
-        }
-        if (!this.primaryKey)
-            throw new TypeError(`You must provide primaryKey fo "${this.name}" entity`);
-        if (!this.getProperty(this.primaryKey))
-            throw new TypeError(`"${this.name}" entity has no such property named "${this.primaryKey}" which defined as primary key`);
-    }
-    get primaryKey() {
-        return this._args.primaryKey;
-    }
-}

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

@@ -1,15 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import { nodeInspectCustom } from '../../utils/terminal-utils.js';
-import type { OpraDocument } from '../opra-document.js';
-import { DataType } from './data-type.js';
-export declare class SimpleType extends DataType {
-    protected readonly _args: OpraSchema.SimpleType;
-    readonly base?: SimpleType;
-    constructor(owner: OpraDocument, args: StrictOmit<OpraSchema.SimpleType, 'kind'>, base?: SimpleType);
-    get type(): 'boolean' | 'number' | 'integer' | 'string';
-    get format(): string | undefined;
-    get default(): boolean | number | string | undefined;
-    toString(): string;
-    [nodeInspectCustom](): string;
-}

package/esm/implementation/data-type/simple-type.js

@@ -1,26 +0,0 @@
-import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../../utils/terminal-utils.js';
-import { DataType } from './data-type.js';
-export class SimpleType extends DataType {
-    constructor(owner, args, base) {
-        super(owner, {
-            kind: 'SimpleType',
-            ...args
-        }, base);
-    }
-    get type() {
-        return this._args.type;
-    }
-    get format() {
-        return this._args.format;
-    }
-    get default() {
-        return this._args.default;
-    }
-    toString() {
-        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
-    }
-    [nodeInspectCustom]() {
-        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
-            ` ${colorFgMagenta + this.name + colorReset}]`;
-    }
-}

package/esm/implementation/opra-document.d.ts

@@ -1,26 +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 { ComplexType } from './data-type/complex-type.js';
-import { DataType } from './data-type/data-type.js';
-import { EntityType } from './data-type/entity-type.js';
-import { SimpleType } from './data-type/simple-type.js';
-import { SchemaGenerator } from './schema-generator.js';
-export declare type OpraDocumentArgs = StrictOmit<OpraSchema.Document, 'version' | 'types'>;
-export declare class OpraDocument {
-    protected readonly _args: OpraDocumentArgs;
-    protected _types: ResponsiveObject<DataType>;
-    constructor(schema: OpraSchema.Document);
-    get name(): string;
-    get info(): OpraSchema.DocumentInfo;
-    get types(): Record<string, DataType>;
-    getDataType(name: string): DataType;
-    getComplexDataType(name: string): ComplexType;
-    getEntityDataType(name: string): EntityType;
-    getSimpleDataType(name: string): SimpleType;
-    toString(): string;
-    [nodeInspectCustom](): string;
-    static create(args: SchemaGenerator.GenerateDocumentArgs): Promise<OpraDocument>;
-    protected _addDataTypes(dataTypes: OpraSchema.DataType[]): void;
-}

package/esm/implementation/opra-document.js

@@ -1,107 +0,0 @@
-import _ from 'lodash';
-import { OpraSchema } from '@opra/schema';
-import { internalDataTypes } from '../utils/internal-data-types.js';
-import { Responsive } from '../utils/responsive-object.js';
-import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/terminal-utils.js';
-import { ComplexType } from './data-type/complex-type.js';
-import { EntityType } from './data-type/entity-type.js';
-import { SimpleType } from './data-type/simple-type.js';
-import { SchemaGenerator } from './schema-generator.js';
-export class OpraDocument {
-    _args;
-    _types = Responsive();
-    constructor(schema) {
-        this._args = _.omit(schema, 'types');
-        if (schema.types)
-            this._addDataTypes(schema.types);
-    }
-    get name() {
-        return this._args.info?.title || '';
-    }
-    get info() {
-        return this._args.info;
-    }
-    get types() {
-        return this._types;
-    }
-    getDataType(name) {
-        const t = this.types[name];
-        if (!t)
-            throw new Error(`Data type "${name}" does not exists`);
-        return t;
-    }
-    getComplexDataType(name) {
-        const t = this.getDataType(name);
-        if (!(t instanceof ComplexType))
-            throw new Error(`Data type "${name}" is not a ComplexType`);
-        return t;
-    }
-    getEntityDataType(name) {
-        const t = this.getDataType(name);
-        if (!(t instanceof EntityType))
-            throw new Error(`Data type "${name}" is not an EntityType`);
-        return t;
-    }
-    getSimpleDataType(name) {
-        const t = this.getDataType(name);
-        if (!(t instanceof SimpleType))
-            throw new Error(`Data type "${name}" is not a SimpleType`);
-        return t;
-    }
-    toString() {
-        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
-    }
-    [nodeInspectCustom]() {
-        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
-            ` ${colorFgMagenta + this.name + colorReset}]`;
-    }
-    static async create(args) {
-        const schema = await SchemaGenerator.generateDocumentSchema(args);
-        return new OpraDocument(schema);
-    }
-    _addDataTypes(dataTypes) {
-        const recursiveSet = new Set();
-        const nameSet = new Set(dataTypes.map(x => x.name));
-        const processDataType = (schema) => {
-            if ((!internalDataTypes.has(schema.name) && !nameSet.has(schema.name)) || this.types[schema.name])
-                return;
-            if (recursiveSet.has(schema.name))
-                throw new TypeError(`Recursive dependency detected. ${Array.from(recursiveSet).join('>')}`);
-            recursiveSet.add(schema.name);
-            let baseType;
-            if (schema.base) {
-                baseType = this.types[schema.base];
-                if (!baseType) {
-                    const baseSchema = dataTypes.find(dt => dt.name.toLowerCase() === schema.base?.toLowerCase()) ||
-                        internalDataTypes.get(schema.base.toLowerCase());
-                    if (!baseSchema)
-                        throw new TypeError(`Base schema (${schema.base}) of data type "${schema.name}" does not exists`);
-                    baseType = processDataType(baseSchema);
-                }
-            }
-            let dataType;
-            if (OpraSchema.isSimpleType(schema)) {
-                if (baseType && !(baseType instanceof SimpleType))
-                    throw new TypeError(`Can't extend a SimpleType (${schema.name}) from a ComplexType "${baseType.name}"`);
-                dataType = new SimpleType(this, schema, baseType);
-            }
-            else if (OpraSchema.isComplexType(schema)) {
-                if (baseType && !(baseType instanceof ComplexType))
-                    throw new TypeError(`Can't extend a ComplexType (${schema.name}) from a SimpleType "${baseType.name}"`);
-                dataType = new ComplexType(this, schema, baseType);
-            }
-            else if (OpraSchema.isEntityType(schema)) {
-                if (baseType && !(baseType instanceof ComplexType))
-                    throw new TypeError(`Can't extend an EntityType (${schema.name}) from a SimpleType "${baseType.name}"`);
-                dataType = new EntityType(this, schema, baseType);
-            }
-            else
-                throw new TypeError(`Invalid data type schema`);
-            nameSet.delete(schema.name);
-            this.types[dataType.name] = dataType;
-            recursiveSet.delete(schema.name);
-            return dataType;
-        };
-        dataTypes.forEach(dataType => processDataType(dataType));
-    }
-}

package/esm/implementation/opra-service.d.ts

@@ -1,20 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import { IResourceContainer } from '../interfaces/resource-container.interface.js';
-import { OpraDocument } from './opra-document.js';
-import { EntityResourceHandler } from './resource/entity-resource-handler.js';
-import { ResourceHandler } from './resource/resource-handler.js';
-import { SchemaGenerator } from './schema-generator.js';
-export declare type OpraServiceArgs = StrictOmit<OpraSchema.Service, 'version' | 'types' | 'resources'>;
-export declare class OpraService extends OpraDocument implements IResourceContainer {
-    protected readonly _args: OpraServiceArgs;
-    protected _resources: import("../utils/responsive-object.js").ResponsiveObject<ResourceHandler>;
-    constructor(schema: OpraSchema.Service);
-    get resources(): Record<string, ResourceHandler>;
-    get servers(): OpraSchema.ServerInfo[] | undefined;
-    getResource<T extends ResourceHandler>(name: string): T;
-    getEntityResource(name: string): EntityResourceHandler;
-    getMetadata(): OpraSchema.ServiceMetadata;
-    protected _addResources(resources: OpraSchema.Resource[]): void;
-    static create(args: SchemaGenerator.GenerateServiceArgs): Promise<OpraService>;
-}

package/esm/implementation/opra-service.js

@@ -1,76 +0,0 @@
-import merge from 'putil-merge';
-import { OpraSchema } from '@opra/schema';
-import { OpraVersion } from '../constants.js';
-import { internalDataTypes } from '../utils/internal-data-types.js';
-import { Responsive } from '../utils/responsive-object.js';
-import { EntityType } from './data-type/entity-type.js';
-import { OpraDocument } from './opra-document.js';
-import { EntityResourceHandler } from './resource/entity-resource-handler.js';
-import { SchemaGenerator } from './schema-generator.js';
-export class OpraService extends OpraDocument {
-    _resources = 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 EntityResourceHandler))
-            throw new Error(`"${name}" is not an EntityResource`);
-        return t;
-    }
-    getMetadata() {
-        const out = {
-            '@opra:metadata': '/$metadata',
-            version: OpraVersion,
-            servers: this.servers?.map(x => merge({}, x, { deep: true })),
-            info: merge({}, this.info, { deep: true }),
-            types: [],
-            resources: []
-        };
-        for (const [k, dataType] of Object.entries(this.types)) {
-            if (!internalDataTypes.has(k))
-                out.types.push(dataType.getMetadata());
-        }
-        for (const resource of Object.values(this.resources)) {
-            out.resources.push(resource.getMetadata());
-        }
-        return out;
-    }
-    _addResources(resources) {
-        for (const r of resources) {
-            if (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 EntityType))
-                    throw new TypeError(`${r.type} is not an EntityType`);
-                this.resources[r.name] = new EntityResourceHandler({ ...r, service: this, dataType });
-            }
-            else
-                throw new TypeError(`Unknown resource kind (${r.kind})`);
-        }
-        // Sort data types by name
-        const newResources = Responsive();
-        Object.keys(this.resources).sort()
-            .forEach(name => newResources[name] = this.resources[name]);
-        this._resources = newResources;
-    }
-    static async create(args) {
-        const schema = await SchemaGenerator.generateServiceSchema(args);
-        return new OpraService(schema);
-    }
-}

package/esm/implementation/resource/container-resource-handler.d.ts

@@ -1,14 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import { IResourceContainer } from '../../interfaces/resource-container.interface.js';
-import { QueryContext } from '../query-context.js';
-import { EntityResourceHandler } from './entity-resource-handler.js';
-import { ResourceHandler } from './resource-handler.js';
-export declare type ContainerResourceControllerArgs = StrictOmit<OpraSchema.ContainerResource, 'kind'> & {};
-export declare class ContainerResourceHandler extends ResourceHandler implements IResourceContainer {
-    protected readonly _args: OpraSchema.ContainerResource;
-    constructor(args: ContainerResourceControllerArgs);
-    getResource<T extends ResourceHandler>(name: string): T;
-    getEntityResource(name: string): EntityResourceHandler;
-    execute(ctx: QueryContext): Promise<void>;
-}

package/esm/implementation/resource/container-resource-handler.js

@@ -1,26 +0,0 @@
-import { EntityResourceHandler } from './entity-resource-handler.js';
-import { ResourceHandler } from './resource-handler.js';
-export class ContainerResourceHandler extends ResourceHandler {
-    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 EntityResourceHandler))
-            throw new Error(`"${name}" is not an EntityResource`);
-        return t;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    execute(ctx) {
-        return Promise.resolve(undefined);
-    }
-}

package/esm/implementation/resource/entity-resource-handler.d.ts

@@ -1,18 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import { EntityType } from '../data-type/entity-type.js';
-import { OpraService } from '../opra-service.js';
-import { QueryContext } from '../query-context.js';
-import { ResourceHandler } from './resource-handler.js';
-export declare type EntityResourceControllerArgs = StrictOmit<OpraSchema.EntityResource, 'kind'> & {
-    service: OpraService;
-    dataType: EntityType;
-};
-export declare class EntityResourceHandler extends ResourceHandler {
-    protected readonly _args: OpraSchema.EntityResource;
-    readonly service: OpraService;
-    readonly dataType: EntityType;
-    constructor(args: EntityResourceControllerArgs);
-    execute(ctx: QueryContext): Promise<void>;
-    _executeFn(ctx: QueryContext, queryType: string): Promise<any>;
-}

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

@@ -1,98 +0,0 @@
-import _ from 'lodash';
-import { translate } from '@opra/i18n';
-import { ForbiddenError, ResourceNotFoundError } from '../../exception/index.js';
-import { OpraQuery } from '../../interfaces/query.interface.js';
-import { ComplexType } from '../data-type/complex-type.js';
-import { EntityType } from '../data-type/entity-type.js';
-import { ResourceHandler } from './resource-handler.js';
-export class EntityResourceHandler extends ResourceHandler {
-    service;
-    dataType;
-    constructor(args) {
-        super({
-            kind: 'EntityResource',
-            ..._.omit(args, ['dataType', 'service'])
-        });
-        this.dataType = args.dataType;
-        this.service = args.service;
-        // noinspection SuspiciousTypeOfGuard
-        if (!(args.dataType instanceof EntityType))
-            throw new TypeError(`You should provide an EntityType for EntityResourceController`);
-    }
-    async execute(ctx) {
-        const { query } = ctx;
-        if (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 ForbiddenError({
-                message: 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 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 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
-        };
-    }
-}

package/esm/implementation/resource/resource-handler.d.ts

@@ -1,15 +0,0 @@
-import { OpraSchema } from '@opra/schema';
-import { nodeInspectCustom } from '../../utils/terminal-utils.js';
-import { QueryContext } from '../query-context.js';
-export declare abstract class ResourceHandler {
-    protected readonly _args: OpraSchema.Resource;
-    protected path: string;
-    protected constructor(args: OpraSchema.Resource);
-    get name(): string;
-    get description(): string | undefined;
-    toString(): string;
-    prepare(ctx: QueryContext): Promise<void>;
-    getMetadata(): any;
-    abstract execute(ctx: QueryContext): Promise<void>;
-    [nodeInspectCustom](): string;
-}

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

@@ -1,40 +0,0 @@
-import merge from 'putil-merge';
-import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../../utils/terminal-utils.js';
-export 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 merge({}, {
-            ...this._args,
-            instance: undefined,
-        }, {
-            deep: true,
-            filter: (source, key) => {
-                return (key !== 'instance' && typeof source[key] !== 'function' && source[key] != null);
-            }
-        });
-    }
-    [nodeInspectCustom]() {
-        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
-            ` ${colorFgMagenta + this.name + colorReset}]`;
-    }
-}

package/esm/implementation/schema-generator.d.ts

@@ -1,21 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import { ThunkAsync } from '../types.js';
-export declare namespace SchemaGenerator {
-    type GenerateDocumentArgs = StrictOmit<OpraSchema.Document, 'version' | 'types'> & {
-        types?: ThunkAsync<Type | OpraSchema.DataType>[];
-    };
-    type GenerateServiceArgs = StrictOmit<OpraSchema.Service, 'version' | 'types' | 'resources'> & {
-        types?: ThunkAsync<Type | OpraSchema.DataType>[];
-        resources: any[];
-    };
-}
-export declare class SchemaGenerator {
-    protected _dataTypes: Record<string, OpraSchema.DataType>;
-    protected _resources: Record<string, OpraSchema.Resource>;
-    protected constructor();
-    protected addDataType(thunk: ThunkAsync<Type | OpraSchema.DataType>): Promise<OpraSchema.DataType>;
-    addResource(instance: any): Promise<void>;
-    static generateDocumentSchema(args: SchemaGenerator.GenerateDocumentArgs): Promise<OpraSchema.Document>;
-    static generateServiceSchema(args: SchemaGenerator.GenerateServiceArgs): Promise<OpraSchema.Service>;
-}