@opra/core 0.0.12 → 0.1.0

package/esm/implementation/adapter/http-adapter.js

@@ -1,234 +0,0 @@
-import { OpraURL } from '@opra/url';
-import { OpraVersion } from '../../constants.js';
-import { HttpHeaders, HttpStatus } from '../../enums/index.js';
-import { ApiException, BadRequestError, InternalServerError, MethodNotAllowedError, NotFoundError, } from '../../exception/index.js';
-import { wrapError } from '../../exception/wrap-error.js';
-import { OpraQuery } from '../../interfaces/query.interface.js';
-import { Headers } from '../../utils/headers.js';
-import { ComplexType } from '../data-type/complex-type.js';
-import { QueryContext } from '../query-context.js';
-import { ContainerResourceHandler } from '../resource/container-resource-handler.js';
-import { EntityResourceHandler } from '../resource/entity-resource-handler.js';
-import { OpraAdapter } from './adapter.js';
-export class OpraHttpAdapter extends OpraAdapter {
-    prepareRequests(executionContext) {
-        const req = executionContext.getRequestWrapper();
-        // todo implement batch requests
-        if (this.isBatch(executionContext)) {
-            throw new Error('not implemented yet');
-        }
-        const url = new OpraURL(req.getUrl());
-        return [
-            this.prepareRequest(executionContext, url, req.getMethod(), Headers.from(req.getHeaders()), req.getBody())
-        ];
-    }
-    prepareRequest(executionContext, url, method, headers, body) {
-        if (!url.path.size)
-            throw new BadRequestError();
-        if (method !== 'GET' && url.path.size > 1)
-            throw new BadRequestError();
-        const query = this.buildQuery(url, method, body);
-        if (!query)
-            throw new MethodNotAllowedError({
-                message: `Method "${method}" is not allowed by target resource`
-            });
-        return new QueryContext({
-            service: this.service,
-            executionContext,
-            query,
-            headers,
-            params: url.searchParams,
-            continueOnError: query.operation === 'read'
-        });
-    }
-    buildQuery(url, method, body) {
-        let container = this.service;
-        try {
-            let pathIndex = 0;
-            const pathLen = url.path.size;
-            while (pathIndex < pathLen) {
-                let p = url.path.get(pathIndex++);
-                const resource = container.getResource(p.resource);
-                // Move through path directories (containers)
-                if (resource instanceof ContainerResourceHandler) {
-                    container = resource;
-                }
-                else {
-                    method = method.toUpperCase();
-                    if (resource instanceof EntityResourceHandler) {
-                        const scope = p.key ? 'instance' : 'collection';
-                        if (pathIndex < pathLen && !(method === 'GET' && scope === 'instance'))
-                            return;
-                        let query;
-                        switch (method) {
-                            case 'GET': {
-                                if (scope === 'collection') {
-                                    query = OpraQuery.forSearch(resource, {
-                                        filter: url.searchParams.get('$filter'),
-                                        limit: url.searchParams.get('$limit'),
-                                        skip: url.searchParams.get('$skip'),
-                                        distinct: url.searchParams.get('$distinct'),
-                                        count: url.searchParams.get('$count'),
-                                        sort: url.searchParams.get('$sort'),
-                                        pick: url.searchParams.get('$pick'),
-                                        omit: url.searchParams.get('$omit'),
-                                        include: url.searchParams.get('$include'),
-                                    });
-                                }
-                                else {
-                                    query = OpraQuery.forGet(resource, p.key, {
-                                        pick: url.searchParams.get('$pick'),
-                                        omit: url.searchParams.get('$omit'),
-                                        include: url.searchParams.get('$include')
-                                    });
-                                    // Move through properties
-                                    let nested;
-                                    let path = resource.name;
-                                    while (pathIndex < pathLen) {
-                                        const dataType = nested
-                                            ? this.service.getDataType(nested.property.type || 'string')
-                                            : query.resource.dataType;
-                                        if (!(dataType instanceof ComplexType))
-                                            throw new Error(`"${path}" is not a ComplexType and has no properties.`);
-                                        p = url.path.get(pathIndex++);
-                                        path += '.' + p.resource;
-                                        const prop = dataType.properties?.[p.resource];
-                                        if (!prop)
-                                            throw new NotFoundError({ message: `Invalid or unknown resource path (${path})` });
-                                        const q = OpraQuery.forGetProperty(prop);
-                                        if (nested) {
-                                            nested.nested = q;
-                                        }
-                                        else {
-                                            query.nested = q;
-                                        }
-                                        nested = q;
-                                    }
-                                }
-                                break;
-                            }
-                            case 'DELETE': {
-                                if (scope === 'collection') {
-                                    query = OpraQuery.forDeleteMany(resource, {
-                                        filter: url.searchParams.get('$filter'),
-                                    });
-                                }
-                                else {
-                                    query = OpraQuery.forDelete(resource, p.key);
-                                }
-                                break;
-                            }
-                            case 'POST': {
-                                if (scope === 'collection') {
-                                    query = OpraQuery.forCreate(resource, body, {
-                                        pick: url.searchParams.get('$pick'),
-                                        omit: url.searchParams.get('$omit'),
-                                        include: url.searchParams.get('$include')
-                                    });
-                                }
-                                break;
-                            }
-                            case 'PATCH': {
-                                if (scope === 'collection') {
-                                    query = OpraQuery.forUpdateMany(resource, body, {
-                                        filter: url.searchParams.get('$filter')
-                                    });
-                                }
-                                else {
-                                    query = OpraQuery.forUpdate(resource, p.key, body, {
-                                        pick: url.searchParams.get('$pick'),
-                                        omit: url.searchParams.get('$omit'),
-                                        include: url.searchParams.get('$include')
-                                    });
-                                }
-                                break;
-                            }
-                        }
-                        return query;
-                    }
-                }
-            }
-            throw new InternalServerError();
-        }
-        catch (e) {
-            if (e instanceof ApiException)
-                throw e;
-            throw new BadRequestError({ message: e.message });
-        }
-    }
-    async sendResponse(executionContext, queryContexts) {
-        const outputPackets = [];
-        for (const ctx of queryContexts) {
-            const v = this.createOutput(ctx);
-            outputPackets.push(v);
-        }
-        if (this.isBatch(executionContext)) {
-            // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
-            return;
-        }
-        if (!outputPackets.length) {
-            const err = new NotFoundError();
-            outputPackets.push({
-                status: err.status,
-                body: {
-                    errors: [err.response]
-                }
-            });
-        }
-        const out = outputPackets[0];
-        const resp = executionContext.getResponseWrapper();
-        resp.setStatus(out.status);
-        resp.setHeader(HttpHeaders.Content_Type, 'application/json');
-        resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
-        resp.setHeader(HttpHeaders.Pragma, 'no-cache');
-        resp.setHeader(HttpHeaders.Expires, '-1');
-        resp.setHeader(HttpHeaders.X_Opra_Version, OpraVersion);
-        if (out.headers) {
-            for (const [k, v] of Object.entries(out.headers)) {
-                resp.setHeader(k, v);
-            }
-        }
-        resp.send(JSON.stringify(out.body));
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    isBatch(executionContext) {
-        return false;
-    }
-    createOutput(ctx) {
-        const { query } = ctx;
-        let status = ctx.response.status;
-        let body = ctx.response.value || {};
-        const errors = ctx.response.errors?.map(e => wrapError(e));
-        if (errors && errors.length) {
-            if (!status || status < 400) {
-                status = 0;
-                for (const e of errors) {
-                    status = Math.max(status, e.status || status);
-                }
-                if (status < HttpStatus.BAD_REQUEST)
-                    status = HttpStatus.INTERNAL_SERVER_ERROR;
-            }
-            body.errors = errors.map(e => e.response);
-        }
-        else {
-            delete body.errors;
-            status = status || (query.operation === 'create' ? HttpStatus.CREATED : HttpStatus.OK);
-        }
-        body = this.i18n.deep(body);
-        return {
-            status,
-            headers: ctx.response.headers,
-            body
-        };
-    }
-    async sendError(executionContext, error) {
-        const resp = executionContext.getResponseWrapper();
-        resp.setStatus(error.status || 500);
-        resp.setHeader(HttpHeaders.Content_Type, 'application/json');
-        resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
-        resp.setHeader(HttpHeaders.Pragma, 'no-cache');
-        resp.setHeader(HttpHeaders.Expires, '-1');
-        resp.setHeader(HttpHeaders.X_Opra_Version, OpraVersion);
-        resp.send(JSON.stringify(error.response));
-    }
-}

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

@@ -1,18 +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;
-    toString(): string;
-    [nodeInspectCustom](): string;
-}

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

@@ -1,35 +0,0 @@
-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;
-    }
-    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,15 +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 ctor(): Type;
-    is(typeName: string): boolean;
-}

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

@@ -1,31 +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 ctor() {
-        return this._args.ctor;
-    }
-    is(typeName) {
-        return this.name === typeName || !!(this.base && this.base.is(typeName));
-    }
-}

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 { SqbConnect } 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 (args.ctor) {
-            const sqbEntity = 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,111 +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) {
-                if (!this.types[schema.base]) {
-                    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));
-        // Sort data types by name
-        const newTypes = Responsive();
-        Object.keys(this.types).sort()
-            .forEach(name => newTypes[name] = this.types[name]);
-        this._types = newTypes;
-    }
-}

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

@@ -1,19 +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;
-    protected _addResources(resources: OpraSchema.Resource[]): void;
-    static create(args: SchemaGenerator.GenerateServiceArgs): Promise<OpraService>;
-}

package/esm/implementation/opra-service.js

@@ -1,55 +0,0 @@
-import { OpraSchema } from '@opra/schema';
-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;
-    }
-    _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>;
-}