@opra/core 0.0.13 → 0.1.1

package/esm/interfaces/query.interface.js

@@ -1,6 +1,6 @@
 import _ from 'lodash';
-import { ComplexType } from '../implementation/data-type/complex-type.js';
-import { stringPathToObjectTree } from '../utils/string-path-to-object-tree.js';
+import { ComplexType } from '@opra/schema';
+import { pathToTree } from '../utils/path-to-tree.js';
 export var OpraQuery;
 (function (OpraQuery) {
     function forCreate(resource, values, options) {
@@ -21,7 +21,7 @@ export var OpraQuery;
         return out;
     }
     OpraQuery.forCreate = forCreate;
-    function forGetMetadata(resourcePath, options) {
+    function forGetSchema(resourcePath, options) {
         // if (options?.pick)
         //   options.pick = normalizePick(resource, options.pick);
         // if (options?.omit)
@@ -29,7 +29,7 @@ export var OpraQuery;
         // if (options?.include)
         //   options.include = normalizePick(resource, options.include);
         const out = {
-            queryType: 'metadata',
+            queryType: 'schema',
             scope: 'instance',
             resourcePath,
             operation: 'read',
@@ -37,7 +37,7 @@ export var OpraQuery;
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    OpraQuery.forGetMetadata = forGetMetadata;
+    OpraQuery.forGetSchema = forGetSchema;
     function forGetEntity(resource, key, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -164,19 +164,19 @@ function checkKeyFields(resource, key) {
         throw new Error(`"${resource.name}" has no primary key`);
 }
 function normalizePick(resource, fields) {
-    const fieldsTree = stringPathToObjectTree(fields) || {};
+    const fieldsTree = pathToTree(fields) || {};
     return _normalizeFieldsList([], resource.service, resource, resource.dataType, fieldsTree, '', {
-        additionalProperties: true
+        additionalFields: true
     });
 }
 function _normalizeFieldsList(target, service, resource, dataType, node, parentPath = '', options) {
     let curPath = '';
     for (const k of Object.keys(node)) {
         const nodeVal = node[k];
-        const prop = dataType?.properties?.[k];
+        const prop = dataType?.fields.get(k);
         if (!prop) {
             curPath = parentPath ? parentPath + '.' + k : k;
-            if (!options?.additionalProperties || (dataType && !dataType.additionalProperties))
+            if (!options?.additionalFields || (dataType && !dataType.additionalFields))
                 throw new TypeError(`Unknown field path "${resource.name + '.' + curPath}"`);
             if (typeof nodeVal === 'object')
                 _normalizeFieldsList(target, service, resource, undefined, nodeVal, curPath, options);
@@ -187,7 +187,7 @@ function _normalizeFieldsList(target, service, resource, dataType, node, parentP
         curPath = parentPath ? parentPath + '.' + prop.name : prop.name;
         const propType = service.getDataType(prop.type || 'string');
         if (typeof nodeVal === 'object') {
-            if (!(propType instanceof ComplexType))
+            if (!(propType && propType instanceof ComplexType))
                 throw new TypeError(`"${curPath}" is not a complex type and has no sub fields`);
             if (target.findIndex(x => x === parentPath) >= 0)
                 continue;

package/esm/services/json-data-service.d.ts

@@ -1,9 +1,9 @@
 import { Maybe } from 'ts-gems';
 import { Expression } from '@opra/url';
 import { QueryContext } from '../implementation/query-context.js';
+import { IEntityService } from '../interfaces/entity-service.interface.js';
 import { OpraQuery } from '../interfaces/query.interface.js';
 import { EntityInput, EntityOutput, QueryType } from '../types.js';
-import { IEntityService } from './entity-resource-controller.js';
 export interface JsonDataServiceAgs<T> {
     resourceName: string;
     data: T[];
@@ -56,7 +56,7 @@ export declare class JsonDataService<T, TOutput = EntityOutput<T>> implements IE
     updateMany(data: EntityInput<T>, options?: JsonDataService.UpdateManyOptions): number;
     delete(keyValue: any): boolean;
     deleteMany(options?: JsonDataService.DeleteManyOptions): number;
-    static filterProperties(obj: any, pick: string[] | undefined, omit: string[] | undefined, include: string[] | undefined): any;
+    static filterFields(obj: any, pick: string[] | undefined, omit: string[] | undefined, include: string[] | undefined): any;
     static prepare(query: OpraQuery): {
         method: QueryType;
         options: any;

package/esm/services/json-data-service.js

@@ -25,7 +25,7 @@ export class JsonDataService {
     get(keyValue, options) {
         const primaryKey = this.primaryKey;
         let v = this.data.find(x => '' + x[primaryKey] === '' + keyValue);
-        v = JsonDataService.filterProperties(v, options?.pick, options?.omit, options?.include);
+        v = JsonDataService.filterFields(v, options?.pick, options?.omit, options?.include);
         return v;
     }
     count(options) {
@@ -40,20 +40,20 @@ export class JsonDataService {
         }
         else
             out = this.data;
-        return out.map(v => JsonDataService.filterProperties(v, options?.pick, options?.omit, options?.include));
+        return out.map(v => JsonDataService.filterFields(v, options?.pick, options?.omit, options?.include));
     }
     create(data, options) {
         if (this.get(data[this.primaryKey]))
             throw new ResourceConflictError(this.resourceName, this.primaryKey);
         this.data.push(data);
-        return JsonDataService.filterProperties(data, options?.pick, options?.omit, options?.include);
+        return JsonDataService.filterFields(data, options?.pick, options?.omit, options?.include);
     }
     update(keyValue, data, options) {
         const primaryKey = this.primaryKey;
         const i = this.data.findIndex(x => '' + x[primaryKey] === '' + keyValue);
         if (i >= 0) {
             data = Object.assign(this.data[i], data);
-            return JsonDataService.filterProperties(data, options?.pick, options?.omit, options?.include);
+            return JsonDataService.filterFields(data, options?.pick, options?.omit, options?.include);
         }
     }
     updateMany(data, options) {
@@ -77,7 +77,13 @@ export class JsonDataService {
         this.data = this.data.filter(x => !items.includes(x));
         return items.length;
     }
-    static filterProperties(obj, pick, omit, include) {
+    static filterFields(obj, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    pick, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    omit, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    include) {
         if (!obj)
             return;
         return obj;

package/esm/types.d.ts

@@ -1,13 +1,6 @@
-import type { Type } from 'ts-gems';
 import { Builtin, DeepPickWritable } from 'ts-gems';
 import { OpraSchema } from '@opra/schema';
-export declare type Thunk<T> = T | (() => T);
-export declare type ThunkAsync<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
-export declare type TypeThunk<T = any> = Thunk<Type<T>>;
-export declare type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
-export declare type QueryScope = 'collection' | 'instance' | 'property';
-export declare type QueryType = OpraSchema.EntityResolverType | 'metadata' | 'execute';
-export declare type OperationType = 'create' | 'read' | 'update' | 'patch' | 'delete' | 'execute';
+export declare type QueryType = OpraSchema.EntityMethodType | 'schema' | 'execute';
 export declare type KeyValue = string | number | boolean | object;
 export declare type EntityInput<T> = DeepNullableIfPartial<DeepPickWritable<T>>;
 export declare type EntityOutput<T> = DeepNullableIfPartial<T>;

package/esm/utils/create-i18n.d.ts

@@ -1,3 +1,3 @@
 import { I18n } from '@opra/i18n';
-import { OpraAdapter } from '../implementation/adapter/adapter.js';
+import { OpraAdapter } from '../implementation/adapter.js';
 export declare function createI18n(options?: OpraAdapter.I18nOptions): Promise<I18n>;

package/esm/utils/path-to-tree.d.ts

@@ -0,0 +1,4 @@
+export interface ObjectTree {
+    [key: string]: boolean | ObjectTree;
+}
+export declare function pathToTree(arr: string[]): ObjectTree | undefined;

package/esm/utils/{string-path-to-object-tree.js → path-to-tree.js}

@@ -1,5 +1,5 @@
 const dotPattern = /^([^.]+)\.(.*)$/;
-export function stringPathToObjectTree(arr) {
+export function pathToTree(arr) {
     if (!arr.length)
         return;
     return _stringPathToObjectTree(arr, {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.0.13",
+  "version": "0.1.1",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -27,14 +27,14 @@
     "clean:cover": "rimraf ../../coverage/core"
   },
   "dependencies": {
-    "@opra/i18n": "^0.0.13",
-    "@opra/optionals": "^0.0.13",
-    "@opra/schema": "^0.0.13",
-    "@opra/url": "^0.0.13",
+    "@opra/i18n": "^0.1.1",
+    "@opra/optionals": "^0.1.1",
+    "@opra/schema": "^0.1.1",
+    "@opra/url": "^0.1.1",
     "lodash": "^4.17.21",
     "putil-isplainobject": "^1.1.4",
     "putil-varhelpers": "^1.6.4",
-    "putil-merge": "^3.8.0",
+    "putil-merge": "^3.9.0",
     "rule-judgment": "^1.1.5",
     "strict-typed-events": "^2.2.0",
     "ts-gems": "^2.2.0"

package/cjs/constants.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESOLVER_METADATA = exports.RESOURCE_METADATA = exports.OpraVersion = void 0;
-exports.OpraVersion = '1.0';
-exports.RESOURCE_METADATA = 'opra:resource.metadata';
-exports.RESOLVER_METADATA = 'opra:resolver.metadata';

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

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiEntityResource = void 0;
-const tslib_1 = require("tslib");
-require("reflect-metadata");
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const constants_js_1 = require("../constants.js");
-const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
-const NAME_PATTERN = /^(.*)Resource$/;
-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, lodash_1.default.omit(options, Object.keys(meta)));
-        Reflect.defineMetadata(constants_js_1.RESOURCE_METADATA, meta, target);
-        /* Define Injectable metadata for NestJS support*/
-        Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
-    };
-}
-exports.ApiEntityResource = ApiEntityResource;

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

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiResolver = void 0;
-const constants_js_1 = require("../constants.js");
-function ApiResolver(options) {
-    return (target, propertyKey) => {
-        const metadata = {
-            ...options
-        };
-        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
-    };
-}
-exports.ApiResolver = ApiResolver;

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

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ComplexType = void 0;
-const tslib_1 = require("tslib");
-const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
-const responsive_object_js_1 = require("../../utils/responsive-object.js");
-const terminal_utils_js_1 = require("../../utils/terminal-utils.js");
-const data_type_js_1 = require("./data-type.js");
-class ComplexType extends data_type_js_1.DataType {
-    ownProperties;
-    properties;
-    constructor(owner, args, base) {
-        super(owner, {
-            kind: 'ComplexType',
-            ...args
-        }, base);
-        this.ownProperties = args?.properties && (0, responsive_object_js_1.Responsive)(args.properties);
-        this.properties = (base?.properties || this.ownProperties) &&
-            (0, responsive_object_js_1.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] = (0, putil_merge_1.default)({}, prop, { deep: true });
-            }
-        }
-        return out;
-    }
-    toString() {
-        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
-    }
-    [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.ComplexType = ComplexType;

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

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataType = void 0;
-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,
-        };
-    }
-}
-exports.DataType = DataType;

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

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityType = void 0;
-const tslib_1 = require("tslib");
-const Optionals = tslib_1.__importStar(require("@opra/optionals"));
-const complex_type_js_1 = require("./complex-type.js");
-class EntityType extends complex_type_js_1.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;
-    }
-}
-exports.EntityType = EntityType;

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

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleType = void 0;
-const terminal_utils_js_1 = require("../../utils/terminal-utils.js");
-const data_type_js_1 = require("./data-type.js");
-class SimpleType extends data_type_js_1.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}]`;
-    }
-    [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.SimpleType = SimpleType;

package/cjs/implementation/opra-document.js

@@ -1,112 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraDocument = void 0;
-const tslib_1 = require("tslib");
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const schema_1 = require("@opra/schema");
-const internal_data_types_js_1 = require("../utils/internal-data-types.js");
-const responsive_object_js_1 = require("../utils/responsive-object.js");
-const terminal_utils_js_1 = require("../utils/terminal-utils.js");
-const complex_type_js_1 = require("./data-type/complex-type.js");
-const entity_type_js_1 = require("./data-type/entity-type.js");
-const simple_type_js_1 = require("./data-type/simple-type.js");
-const schema_generator_js_1 = require("./schema-generator.js");
-class OpraDocument {
-    _args;
-    _types = (0, responsive_object_js_1.Responsive)();
-    constructor(schema) {
-        this._args = lodash_1.default.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 complex_type_js_1.ComplexType))
-            throw new Error(`Data type "${name}" is not a ComplexType`);
-        return t;
-    }
-    getEntityDataType(name) {
-        const t = this.getDataType(name);
-        if (!(t instanceof entity_type_js_1.EntityType))
-            throw new Error(`Data type "${name}" is not an EntityType`);
-        return t;
-    }
-    getSimpleDataType(name) {
-        const t = this.getDataType(name);
-        if (!(t instanceof simple_type_js_1.SimpleType))
-            throw new Error(`Data type "${name}" is not a SimpleType`);
-        return t;
-    }
-    toString() {
-        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
-    }
-    [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}]`;
-    }
-    static async create(args) {
-        const schema = await schema_generator_js_1.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 ((!internal_data_types_js_1.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()) ||
-                        internal_data_types_js_1.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 (schema_1.OpraSchema.isSimpleType(schema)) {
-                if (baseType && !(baseType instanceof simple_type_js_1.SimpleType))
-                    throw new TypeError(`Can't extend a SimpleType (${schema.name}) from a ComplexType "${baseType.name}"`);
-                dataType = new simple_type_js_1.SimpleType(this, schema, baseType);
-            }
-            else if (schema_1.OpraSchema.isComplexType(schema)) {
-                if (baseType && !(baseType instanceof complex_type_js_1.ComplexType))
-                    throw new TypeError(`Can't extend a ComplexType (${schema.name}) from a SimpleType "${baseType.name}"`);
-                dataType = new complex_type_js_1.ComplexType(this, schema, baseType);
-            }
-            else if (schema_1.OpraSchema.isEntityType(schema)) {
-                if (baseType && !(baseType instanceof complex_type_js_1.ComplexType))
-                    throw new TypeError(`Can't extend an EntityType (${schema.name}) from a SimpleType "${baseType.name}"`);
-                dataType = new entity_type_js_1.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));
-    }
-}
-exports.OpraDocument = OpraDocument;

package/cjs/implementation/opra-service.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraService = void 0;
-const tslib_1 = require("tslib");
-const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
-const schema_1 = require("@opra/schema");
-const constants_js_1 = require("../constants.js");
-const internal_data_types_js_1 = require("../utils/internal-data-types.js");
-const responsive_object_js_1 = require("../utils/responsive-object.js");
-const entity_type_js_1 = require("./data-type/entity-type.js");
-const opra_document_js_1 = require("./opra-document.js");
-const entity_resource_handler_js_1 = require("./resource/entity-resource-handler.js");
-const schema_generator_js_1 = require("./schema-generator.js");
-class OpraService extends opra_document_js_1.OpraDocument {
-    _resources = (0, responsive_object_js_1.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 entity_resource_handler_js_1.EntityResourceHandler))
-            throw new Error(`"${name}" is not an EntityResource`);
-        return t;
-    }
-    getMetadata() {
-        const out = {
-            '@opra:metadata': '/$metadata',
-            version: constants_js_1.OpraVersion,
-            servers: this.servers?.map(x => (0, putil_merge_1.default)({}, x, { deep: true })),
-            info: (0, putil_merge_1.default)({}, this.info, { deep: true }),
-            types: [],
-            resources: []
-        };
-        for (const [k, dataType] of Object.entries(this.types)) {
-            if (!internal_data_types_js_1.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 (schema_1.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 entity_type_js_1.EntityType))
-                    throw new TypeError(`${r.type} is not an EntityType`);
-                this.resources[r.name] = new entity_resource_handler_js_1.EntityResourceHandler({ ...r, service: this, dataType });
-            }
-            else
-                throw new TypeError(`Unknown resource kind (${r.kind})`);
-        }
-        // Sort data types by name
-        const newResources = (0, responsive_object_js_1.Responsive)();
-        Object.keys(this.resources).sort()
-            .forEach(name => newResources[name] = this.resources[name]);
-        this._resources = newResources;
-    }
-    static async create(args) {
-        const schema = await schema_generator_js_1.SchemaGenerator.generateServiceSchema(args);
-        return new OpraService(schema);
-    }
-}
-exports.OpraService = OpraService;

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

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContainerResourceHandler = void 0;
-const entity_resource_handler_js_1 = require("./entity-resource-handler.js");
-const resource_handler_js_1 = require("./resource-handler.js");
-class ContainerResourceHandler extends resource_handler_js_1.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 entity_resource_handler_js_1.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);
-    }
-}
-exports.ContainerResourceHandler = ContainerResourceHandler;