@opra/core 0.0.5 → 0.0.8

package/cjs/exception/api-exception.js

@@ -2,20 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiException = void 0;
 const index_js_1 = require("../enums/index.js");
-const nodeEnv = process.env.NODE_ENV || '';
 /**
  * Defines the base Opra exception, which is handled by the default Exceptions Handler.
  */
 class ApiException extends Error {
-    originalError;
+    static stackAsDiagnostics = false;
     response;
     status;
-    constructor(response, status) {
-        super();
+    cause;
+    constructor(response, cause) {
+        super('');
         this._initName();
-        this.setStatus(status || index_js_1.HttpStatus.INTERNAL_SERVER_ERROR);
-        if (response instanceof Error)
-            this.originalError = response;
+        if (cause)
+            Object.defineProperty(this, 'cause', { enumerable: false, configurable: true, writable: true, value: cause });
+        else if (response instanceof Error)
+            Object.defineProperty(this, 'cause', { enumerable: false, configurable: true, writable: true, value: response });
+        this.status = index_js_1.HttpStatus.INTERNAL_SERVER_ERROR;
         this._initResponse(response);
     }
     setStatus(status) {
@@ -38,11 +40,7 @@ class ApiException extends Error {
             this.response = {
                 message: x.message || x.details || ('' + init),
             };
-            if (init instanceof Error) {
-                if (nodeEnv === 'dev' || nodeEnv === 'development')
-                    this.response.diagnostics = init.stack;
-            }
-            else
+            if (!(init instanceof Error))
                 Object.assign(this.response, init);
         }
         else {
@@ -50,14 +48,24 @@ class ApiException extends Error {
                 message: '' + init,
             };
         }
+        if (this.cause instanceof Error && this.cause.stack) {
+            if (ApiException.stackAsDiagnostics)
+                this.response.diagnostics = this.cause.stack.split('\n');
+            this.stack = this.cause.stack;
+        }
         if (!this.response.severity)
             if (this.status >= 500)
                 this.response.severity = 'fatal';
             else
                 this.response.severity = 'error';
     }
-    static wrap(response, status) {
-        return response instanceof ApiException ? response : new this(response, status);
+    static wrap(response) {
+        if (response instanceof ApiException)
+            return response;
+        const out = new this(response, response instanceof Error ? response : undefined);
+        if (response instanceof Error)
+            out.stack = response.stack;
+        return out;
     }
 }
 exports.ApiException = ApiException;

package/cjs/exception/errors/bad-request.error.js

@@ -10,13 +10,14 @@ const api_exception_js_1 = require("../api-exception.js");
  * (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
  */
 class BadRequestError extends api_exception_js_1.ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: (0, i18n_1.translate)('error:BAD_REQUEST', 'Bad request'),
             severity: 'error',
             code: 'BAD_REQUEST',
             ...response
-        }, index_js_1.HttpStatus.BAD_REQUEST);
+        }, cause);
+        this.status = index_js_1.HttpStatus.BAD_REQUEST;
     }
 }
 exports.BadRequestError = BadRequestError;

package/cjs/exception/errors/failed-dependency.error.js

@@ -9,13 +9,14 @@ const api_exception_js_1 = require("../api-exception.js");
  * The request failed due to failure of a previous request.
  */
 class FailedDependencyError extends api_exception_js_1.ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: (0, i18n_1.translate)('error:FAILED_DEPENDENCY', 'The request failed due to failure of a previous request.'),
             severity: 'error',
             code: 'FAILED_DEPENDENCY',
             ...response
-        }, index_js_1.HttpStatus.FAILED_DEPENDENCY);
+        }, cause);
+        this.status = index_js_1.HttpStatus.FAILED_DEPENDENCY;
     }
 }
 exports.FailedDependencyError = FailedDependencyError;

package/cjs/exception/errors/forbidden.error.js

@@ -11,13 +11,14 @@ const api_exception_js_1 = require("../api-exception.js");
  * the client's identity is known to the server.
  */
 class ForbiddenError extends api_exception_js_1.ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: (0, i18n_1.translate)('error:FORBIDDEN', 'Forbidden'),
             severity: 'error',
             code: 'FORBIDDEN',
             ...response
-        }, index_js_1.HttpStatus.FORBIDDEN);
+        }, cause);
+        this.status = index_js_1.HttpStatus.FORBIDDEN;
     }
 }
 exports.ForbiddenError = ForbiddenError;

package/cjs/exception/errors/internal-server.error.js

@@ -9,13 +9,14 @@ const api_exception_js_1 = require("../api-exception.js");
  * The server has encountered a situation it does not know how to handle.
  */
 class InternalServerError extends api_exception_js_1.ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: (0, i18n_1.translate)('error:INTERNAL_SERVER_ERROR', 'Internal server error'),
             severity: 'error',
             code: 'INTERNAL_SERVER_ERROR',
             ...response
-        }, index_js_1.HttpStatus.INTERNAL_SERVER_ERROR);
+        }, cause);
+        this.status = index_js_1.HttpStatus.INTERNAL_SERVER_ERROR;
     }
 }
 exports.InternalServerError = InternalServerError;

package/cjs/exception/errors/method-not-allowed.error.js

@@ -10,13 +10,14 @@ const api_exception_js_1 = require("../api-exception.js");
  * For example, an API may not allow calling DELETE to remove a resource.
  */
 class MethodNotAllowedError extends api_exception_js_1.ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: (0, i18n_1.translate)('error:METHOD_NOT_ALLOWED', 'Method Not Allowed'),
             severity: 'error',
             code: 'METHOD_NOT_ALLOWED',
             ...response
-        }, index_js_1.HttpStatus.METHOD_NOT_ALLOWED);
+        }, cause);
+        this.status = index_js_1.HttpStatus.METHOD_NOT_ALLOWED;
     }
 }
 exports.MethodNotAllowedError = MethodNotAllowedError;

package/cjs/exception/errors/not-found.error.js

@@ -13,13 +13,14 @@ const api_exception_js_1 = require("../api-exception.js");
  * frequent occurrence on the web.
  */
 class NotFoundError extends api_exception_js_1.ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: (0, i18n_1.translate)('error:NOT_FOUND', 'Not found'),
             severity: 'error',
             code: 'NOT_FOUND',
             ...response
-        }, index_js_1.HttpStatus.NOT_FOUND);
+        }, cause);
+        this.status = index_js_1.HttpStatus.NOT_FOUND;
     }
 }
 exports.NotFoundError = NotFoundError;

package/cjs/exception/errors/unauthorized.error.js

@@ -10,13 +10,14 @@ const api_exception_js_1 = require("../api-exception.js");
  * That is, the client must authenticate itself to get the requested response.
  */
 class UnauthorizedError extends api_exception_js_1.ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: (0, i18n_1.translate)('error:UNAUTHORIZED', 'Unauthorized'),
             severity: 'error',
             code: 'UNAUTHORIZED',
             ...response
-        }, index_js_1.HttpStatus.UNAUTHORIZED);
+        }, cause);
+        this.status = index_js_1.HttpStatus.UNAUTHORIZED;
     }
 }
 exports.UnauthorizedError = UnauthorizedError;

package/cjs/exception/errors/unprocessable-entity.error.js

@@ -9,13 +9,14 @@ const api_exception_js_1 = require("../api-exception.js");
  * The request was well-formed but was unable to be followed due to semantic errors.
  */
 class UnprocessableEntityError extends api_exception_js_1.ApiException {
-    constructor(response) {
+    constructor(response, cause) {
         super({
             message: (0, i18n_1.translate)('error:UNPROCESSABLE_ENTITY', 'Unprocessable entity'),
             severity: 'error',
             code: 'UNPROCESSABLE_ENTITY',
             ...response
-        }, index_js_1.HttpStatus.UNPROCESSABLE_ENTITY);
+        }, cause);
+        this.status = index_js_1.HttpStatus.UNPROCESSABLE_ENTITY;
     }
 }
 exports.UnprocessableEntityError = UnprocessableEntityError;

package/cjs/exception/wrap-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapError = void 0;
+const api_exception_js_1 = require("./api-exception.js");
+const internal_server_error_js_1 = require("./errors/internal-server.error.js");
+function wrapError(response) {
+    if (response instanceof api_exception_js_1.ApiException)
+        return response;
+    if (response instanceof Error) {
+        const x = response;
+        if (typeof x.status === 'number' || typeof x.getStatus === 'function')
+            return new api_exception_js_1.ApiException(response);
+        return new internal_server_error_js_1.InternalServerError(undefined, response);
+    }
+    return new internal_server_error_js_1.InternalServerError();
+}
+exports.wrapError = wrapError;

package/cjs/implementation/adapter/adapter.js

@@ -1,72 +1,100 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpraAdapter = void 0;
-const types_1 = require("util/types");
 const i18n_1 = require("@opra/i18n");
 const index_js_1 = require("../../exception/index.js");
+const wrap_error_js_1 = require("../../exception/wrap-error.js");
 class OpraAdapter {
     service;
     i18n;
-    constructor(service, options) {
+    constructor(service, i18n) {
         this.service = service;
-        this.i18n = options?.i18n || i18n_1.I18n.defaultInstance;
+        this.i18n = i18n || i18n_1.I18n.defaultInstance;
     }
-    async handler(adapterContext, userContext) {
-        let executionContexts;
+    async handler(adapterContext, userContextResolver) {
+        if (!this.i18n.isInitialized)
+            await this.i18n.init();
+        const executionContexts = [];
+        let requests;
+        let userContext;
         try {
-            executionContexts = this.prepareExecutionContexts(adapterContext, userContext);
-        }
-        catch (e) {
-            const error = index_js_1.InternalServerError.wrap(e);
-            await this.sendError(adapterContext, error);
-            return;
-        }
-        let stop = false;
-        // Read requests can be executed simultaneously, write request should be executed one by one
-        let promises;
-        let exclusive = false;
-        for (const ctx of executionContexts) {
-            const request = ctx.request;
-            const response = ctx.response;
-            exclusive = exclusive || request.query.operationType !== 'read';
-            try {
+            requests = this.prepareRequests(adapterContext);
+            let stop = false;
+            // Read requests can be executed simultaneously, write request should be executed one by one
+            let promises;
+            let exclusive = false;
+            for (const request of requests) {
+                exclusive = exclusive || request.query.operationType !== 'read';
                 // Wait previous read requests before executing update request
                 if (exclusive && promises) {
-                    await Promise.all(promises);
+                    await Promise.allSettled(promises);
                     promises = undefined;
                 }
+                const resource = request.query.resource;
+                const context = this.createExecutionContext(adapterContext, request);
+                executionContexts.push(context);
                 // If previous request in bucket had an error and executed an update
                 // we do not execute next requests
                 if (stop) {
-                    response.errors.push(new index_js_1.FailedDependencyError());
+                    context.response.errors.push(new index_js_1.FailedDependencyError());
+                    continue;
                 }
-                else {
-                    const resource = ctx.request.query.resource;
-                    const v = resource.execute(ctx);
-                    if ((0, types_1.isPromise)(v)) {
-                        if (exclusive)
-                            await v;
-                        else {
-                            promises = promises || [];
-                            promises.push(v);
-                        }
+                try {
+                    const promise = (async () => {
+                        await resource.prepare(context);
+                        if (userContextResolver && !userContext)
+                            userContext = userContextResolver(this.isBatch(adapterContext));
+                        context.userContext = userContext;
+                        await resource.execute(context);
+                    })().catch(e => {
+                        context.response.errors.push(e);
+                    });
+                    if (exclusive)
+                        await promise;
+                    else {
+                        promises = promises || [];
+                        promises.push(promise);
                     }
                     // todo execute sub property queries
                 }
+                catch (e) {
+                    context.response.errors.unshift(e);
+                }
+                if (context.response.errors.length) {
+                    // noinspection SuspiciousTypeOfGuard
+                    context.response.errors = context.response.errors.map(e => (0, wrap_error_js_1.wrapError)(e));
+                    if (exclusive)
+                        stop = stop || !!context.response.errors.find(e => !(e.response.severity === 'warning' || e.response.severity === 'info'));
+                }
             }
-            catch (e) {
-                response.errors.unshift(index_js_1.ApiException.wrap(e));
-            }
-            if (response.errors && response.errors.length) {
-                // noinspection SuspiciousTypeOfGuard
-                response.errors = response.errors.map(e => index_js_1.ApiException.wrap(e));
-                if (exclusive)
-                    stop = stop || !!response.errors.find(e => !(e.response.severity === 'warning' || e.response.severity === 'info'));
+            if (promises)
+                await Promise.allSettled(promises);
+            if (userContext && typeof userContext.onRequestFinish === 'function') {
+                try {
+                    const hasError = !!executionContexts.find(ctx => ctx.response.errors?.length);
+                    await userContext.onRequestFinish(hasError);
+                }
+                catch (e) {
+                    await this.sendError(adapterContext, (0, wrap_error_js_1.wrapError)(e));
+                    return;
+                }
             }
+            await this.sendResponse(adapterContext, executionContexts);
         }
-        if (promises)
-            await Promise.all(promises);
-        await this.sendResponse(adapterContext, executionContexts);
+        catch (e) {
+            const error = (0, wrap_error_js_1.wrapError)(e);
+            await this.sendError(adapterContext, error);
+            return;
+        }
+    }
+    static async initI18n(options) {
+        if (options?.i18n instanceof i18n_1.I18n)
+            return options.i18n;
+        if (typeof options?.i18n === 'function')
+            return options.i18n();
+        const instance = i18n_1.I18n.createInstance(options?.i18n);
+        await instance.init();
+        return instance;
     }
 }
 exports.OpraAdapter = OpraAdapter;

package/cjs/implementation/adapter/express-adapter.js

@@ -4,20 +4,20 @@ exports.OpraExpressAdapter = void 0;
 const url_1 = require("@opra/url");
 const http_adapter_js_1 = require("./http-adapter.js");
 class OpraExpressAdapter extends http_adapter_js_1.OpraHttpAdapter {
-    static init(app, service, options) {
-        const adapter = new OpraExpressAdapter(service, options);
+    static async init(app, service, options) {
+        const i18n = await this.initI18n(options);
+        const adapter = new OpraExpressAdapter(service, i18n);
         const prefix = '/' + (0, url_1.normalizePath)(options?.prefix, true);
         const userContextResolver = options?.userContext;
         app.use(prefix, (request, response, next) => {
             (async () => {
-                const userContext = userContextResolver && await userContextResolver(request);
                 const req = new ExpressRequestWrapper(request);
                 const res = new ExpressResponseWrapper(response);
                 const adapterContext = {
                     getRequest: () => req,
                     getResponse: () => res
                 };
-                await adapter.handler(adapterContext, userContext);
+                await adapter.handler(adapterContext, (isBatch) => userContextResolver && userContextResolver(request, { platform: 'express', isBatch }));
             })().catch(e => next(e));
         });
         return adapter;

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

@@ -5,24 +5,27 @@ const url_1 = require("@opra/url");
 const constants_js_1 = require("../../constants.js");
 const index_js_1 = require("../../enums/index.js");
 const index_js_2 = require("../../exception/index.js");
+const wrap_error_js_1 = require("../../exception/wrap-error.js");
 const execution_query_interface_js_1 = require("../../interfaces/execution-query.interface.js");
 const headers_js_1 = require("../../utils/headers.js");
 const complex_type_js_1 = require("../data-type/complex-type.js");
 const execution_context_js_1 = require("../execution-context.js");
-const container_resource_controller_js_1 = require("../resource/container-resource-controller.js");
-const entity_resource_info_js_1 = require("../resource/entity-resource-info.js");
+const container_resource_handler_js_1 = require("../resource/container-resource-handler.js");
+const entity_resource_handler_js_1 = require("../resource/entity-resource-handler.js");
 const adapter_js_1 = require("./adapter.js");
 class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
-    prepareExecutionContexts(adapterContext, userContext) {
+    prepareRequests(adapterContext) {
         const req = adapterContext.getRequest();
         // todo implement batch requests
         if (this.isBatch(adapterContext)) {
             throw new Error('not implemented yet');
         }
         const url = new url_1.OpraURL(req.getUrl());
-        return [this.prepareExecutionContext(adapterContext, url, req.getMethod(), headers_js_1.Headers.from(req.getHeaders()), req.getBody(), userContext)];
+        return [
+            this.prepareRequest(adapterContext, url, req.getMethod(), headers_js_1.Headers.from(req.getHeaders()), req.getBody())
+        ];
     }
-    prepareExecutionContext(adapterContext, url, method, headers, body, userContext) {
+    prepareRequest(adapterContext, url, method, headers, body) {
         if (!url.path.size)
             throw new index_js_2.BadRequestError();
         if (method !== 'GET' && url.path.size > 1)
@@ -32,23 +35,21 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
             throw new index_js_2.MethodNotAllowedError({
                 message: `Method "${method}" is not allowed by target resource`
             });
-        const request = new execution_context_js_1.ExecutionRequest({
+        return new execution_context_js_1.ExecutionRequest({
             query,
             headers,
             params: url.searchParams,
         });
-        const response = new execution_context_js_1.ExecutionResponse();
-        // noinspection UnnecessaryLocalVariableJS
-        const executionContext = new execution_context_js_1.ExecutionContext({
+    }
+    createExecutionContext(adapterContext, request) {
+        return new execution_context_js_1.ExecutionContext({
             type: 'http',
             service: this.service,
             request,
-            response,
+            response: new execution_context_js_1.ExecutionResponse(),
             adapterContext,
-            userContext,
             continueOnError: request.query.operationType === 'read'
         });
-        return executionContext;
     }
     buildQuery(url, method, body) {
         let container = this.service;
@@ -59,12 +60,12 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                 let p = url.path.get(pathIndex++);
                 const resource = container.getResource(p.resource);
                 // Move through path directories (containers)
-                if (resource instanceof container_resource_controller_js_1.ContainerResourceController) {
+                if (resource instanceof container_resource_handler_js_1.ContainerResourceHandler) {
                     container = resource;
                 }
                 else {
                     method = method.toUpperCase();
-                    if (resource instanceof entity_resource_info_js_1.EntityResourceInfo) {
+                    if (resource instanceof entity_resource_handler_js_1.EntityResourceHandler) {
                         const scope = p.key ? 'instance' : 'collection';
                         if (pathIndex < pathLen && !(method === 'GET' && scope === 'instance'))
                             return;
@@ -77,7 +78,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                                         limit: url.searchParams.get('$limit'),
                                         skip: url.searchParams.get('$skip'),
                                         distinct: url.searchParams.get('$distinct'),
-                                        total: url.searchParams.get('$total'),
+                                        count: url.searchParams.get('$count'),
                                         sort: url.searchParams.get('$sort'),
                                         pick: url.searchParams.get('$pick'),
                                         omit: url.searchParams.get('$omit'),
@@ -85,7 +86,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                                     });
                                 }
                                 else {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forRead(resource, p.key, {
+                                    query = execution_query_interface_js_1.ExecutionQuery.forGet(resource, p.key, {
                                         pick: url.searchParams.get('$pick'),
                                         omit: url.searchParams.get('$omit'),
                                         include: url.searchParams.get('$include')
@@ -104,7 +105,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                                         const prop = dataType.properties?.[p.resource];
                                         if (!prop)
                                             throw new index_js_2.NotFoundError({ message: `Invalid or unknown resource path (${path})` });
-                                        const q = execution_query_interface_js_1.ExecutionQuery.forProperty(prop);
+                                        const q = execution_query_interface_js_1.ExecutionQuery.forGetProperty(prop);
                                         if (nested) {
                                             nested.nested = q;
                                         }
@@ -205,43 +206,25 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
     }
     createOutput(ctx) {
         const { query } = ctx.request;
-        // Determine response status
         let status = ctx.response.status;
-        if (ctx.response.errors.length) {
+        let body = ctx.response.value || {};
+        const errors = ctx.response.errors?.map(e => (0, wrap_error_js_1.wrapError)(e));
+        if (errors && errors.length) {
             if (!status || status < 400) {
                 status = 0;
-                for (const e of ctx.response.errors) {
+                for (const e of errors) {
                     status = Math.max(status, e.status || status);
                 }
                 if (status < index_js_1.HttpStatus.BAD_REQUEST)
                     status = index_js_1.HttpStatus.INTERNAL_SERVER_ERROR;
             }
-        }
-        else
-            status = status || (query.operationType === 'create' ? index_js_1.HttpStatus.CREATED : index_js_1.HttpStatus.OK);
-        let body;
-        let value = ctx.response.value;
-        if (query.queryType === 'search') {
-            body = {
-                // '@origin': ctx.resource.name + (ctx.request.resultPath ? '.' + ctx.request.resultPath : ''),
-                items: ctx.response.value,
-                total: ctx.response.total
-            };
+            body.errors = errors.map(e => e.response);
         }
         else {
-            // Move to sub property if result path defined
-            if (value && ctx.request.resultPath) {
-                const pathArray = ctx.request.resultPath.split('.');
-                for (const property of pathArray) {
-                    value = value && typeof value === 'object' && value[property];
-                }
-            }
-            body = value;
-        }
-        if (ctx.response.errors?.length) {
-            body = body || {};
-            body.errors = ctx.response.errors.map(e => e.response);
+            delete body.errors;
+            status = status || (query.operationType === 'create' ? index_js_1.HttpStatus.CREATED : index_js_1.HttpStatus.OK);
         }
+        body = this.i18n.deep(body);
         return {
             status,
             headers: ctx.response.headers,

package/cjs/implementation/opra-service.js

@@ -5,7 +5,7 @@ const schema_1 = require("@opra/schema");
 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_info_js_1 = require("./resource/entity-resource-info.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)();
@@ -28,7 +28,7 @@ class OpraService extends opra_document_js_1.OpraDocument {
     }
     getEntityResource(name) {
         const t = this.getResource(name);
-        if (!(t instanceof entity_resource_info_js_1.EntityResourceInfo))
+        if (!(t instanceof entity_resource_handler_js_1.EntityResourceHandler))
             throw new Error(`"${name}" is not an EntityResource`);
         return t;
     }
@@ -40,7 +40,7 @@ class OpraService extends opra_document_js_1.OpraDocument {
                     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_info_js_1.EntityResourceInfo({ ...r, service: this, dataType });
+                this.resources[r.name] = new entity_resource_handler_js_1.EntityResourceHandler({ ...r, service: this, dataType });
             }
             else
                 throw new TypeError(`Unknown resource kind (${r.kind})`);

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

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