@opra/core 0.0.8 → 0.0.9

package/cjs/exception/api-exception.js

@@ -13,52 +13,49 @@ class ApiException extends Error {
     constructor(response, cause) {
         super('');
         this._initName();
+        this.status = index_js_1.HttpStatus.INTERNAL_SERVER_ERROR;
+        cause = cause || (response instanceof Error ? response : undefined);
         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) {
-        this.status = status;
-        return this;
-    }
-    _initName() {
-        this.name = this.constructor.name;
-    }
-    _initResponse(init) {
-        if (init && typeof init === 'object') {
-            const x = init;
-            if (typeof x.status === 'number')
-                this.setStatus(x.status);
-            else if (typeof x.getStatus === 'function')
-                this.setStatus(x.getStatus());
-        }
-        if (typeof init === 'object') {
-            const x = init;
-            this.response = {
-                message: x.message || x.details || ('' + init),
-            };
-            if (!(init instanceof Error))
-                Object.assign(this.response, init);
-        }
-        else {
-            this.response = {
-                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 (response instanceof Error)
+            this._initErrorInstance(response);
+        else if (typeof response === 'string')
+            this._initResponse({ message: response });
+        else
+            this._initResponse(response);
         if (!this.response.severity)
             if (this.status >= 500)
                 this.response.severity = 'fatal';
             else
                 this.response.severity = 'error';
     }
+    setStatus(status) {
+        this.status = status;
+        return this;
+    }
+    _initName() {
+        this.name = this.constructor.name;
+    }
+    _initErrorInstance(init) {
+        this._initResponse({
+            message: init.message
+        });
+        if (typeof init.status === 'number')
+            this.setStatus(init.status);
+        else if (typeof init.getStatus === 'function')
+            this.setStatus(init.getStatus());
+    }
+    _initResponse(response) {
+        this.response = {
+            message: 'Unknown error',
+            ...response
+        };
+    }
     static wrap(response) {
         if (response instanceof ApiException)
             return response;

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

@@ -11,13 +11,16 @@ const api_exception_js_1 = require("../api-exception.js");
  */
 class BadRequestError extends api_exception_js_1.ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = index_js_1.HttpStatus.BAD_REQUEST;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: (0, i18n_1.translate)('error:BAD_REQUEST', 'Bad request'),
             severity: 'error',
             code: 'BAD_REQUEST',
             ...response
-        }, cause);
-        this.status = index_js_1.HttpStatus.BAD_REQUEST;
+        });
     }
 }
 exports.BadRequestError = BadRequestError;

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

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

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

@@ -12,13 +12,16 @@ const api_exception_js_1 = require("../api-exception.js");
  */
 class ForbiddenError extends api_exception_js_1.ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = index_js_1.HttpStatus.FORBIDDEN;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: (0, i18n_1.translate)('error:FORBIDDEN', 'Forbidden'),
             severity: 'error',
             code: 'FORBIDDEN',
             ...response
-        }, cause);
-        this.status = index_js_1.HttpStatus.FORBIDDEN;
+        });
     }
 }
 exports.ForbiddenError = ForbiddenError;

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalServerError = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const i18n_1 = require("@opra/i18n");
 const index_js_1 = require("../../enums/index.js");
 const api_exception_js_1 = require("../api-exception.js");
@@ -10,13 +12,16 @@ const api_exception_js_1 = require("../api-exception.js");
  */
 class InternalServerError extends api_exception_js_1.ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = index_js_1.HttpStatus.INTERNAL_SERVER_ERROR;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: (0, i18n_1.translate)('error:INTERNAL_SERVER_ERROR', 'Internal server error'),
             severity: 'error',
             code: 'INTERNAL_SERVER_ERROR',
-            ...response
-        }, cause);
-        this.status = index_js_1.HttpStatus.INTERNAL_SERVER_ERROR;
+            ...lodash_1.default.omitBy(response, lodash_1.default.isNil)
+        });
     }
 }
 exports.InternalServerError = InternalServerError;

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

@@ -11,13 +11,16 @@ const api_exception_js_1 = require("../api-exception.js");
  */
 class MethodNotAllowedError extends api_exception_js_1.ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = index_js_1.HttpStatus.METHOD_NOT_ALLOWED;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: (0, i18n_1.translate)('error:METHOD_NOT_ALLOWED', 'Method Not Allowed'),
             severity: 'error',
             code: 'METHOD_NOT_ALLOWED',
             ...response
-        }, cause);
-        this.status = index_js_1.HttpStatus.METHOD_NOT_ALLOWED;
+        });
     }
 }
 exports.MethodNotAllowedError = MethodNotAllowedError;

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

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

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

@@ -11,13 +11,16 @@ const api_exception_js_1 = require("../api-exception.js");
  */
 class UnauthorizedError extends api_exception_js_1.ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = index_js_1.HttpStatus.UNAUTHORIZED;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: (0, i18n_1.translate)('error:UNAUTHORIZED', 'Unauthorized'),
             severity: 'error',
             code: 'UNAUTHORIZED',
             ...response
-        }, cause);
-        this.status = index_js_1.HttpStatus.UNAUTHORIZED;
+        });
     }
 }
 exports.UnauthorizedError = UnauthorizedError;

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

@@ -10,13 +10,16 @@ const api_exception_js_1 = require("../api-exception.js");
  */
 class UnprocessableEntityError extends api_exception_js_1.ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = index_js_1.HttpStatus.UNPROCESSABLE_ENTITY;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: (0, i18n_1.translate)('error:UNPROCESSABLE_ENTITY', 'Unprocessable entity'),
             severity: 'error',
             code: 'UNPROCESSABLE_ENTITY',
             ...response
-        }, cause);
-        this.status = index_js_1.HttpStatus.UNPROCESSABLE_ENTITY;
+        });
     }
 }
 exports.UnprocessableEntityError = UnprocessableEntityError;

package/cjs/exception/wrap-error.js

@@ -10,7 +10,7 @@ function wrapError(response) {
         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(response);
     }
     return new internal_server_error_js_1.InternalServerError();
 }

package/cjs/implementation/adapter/adapter.js

@@ -1,38 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpraAdapter = void 0;
+const strict_typed_events_1 = require("strict-typed-events");
 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, i18n) {
+    userContextResolver;
+    constructor(service, options) {
         this.service = service;
-        this.i18n = i18n || i18n_1.I18n.defaultInstance;
+        this.i18n = options?.i18n || i18n_1.I18n.defaultInstance;
+        this.userContextResolver = options?.userContext;
     }
-    async handler(adapterContext, userContextResolver) {
+    async handler(executionContext) {
         if (!this.i18n.isInitialized)
             await this.i18n.init();
-        const executionContexts = [];
-        let requests;
+        let queryContexts;
         let userContext;
+        let failed = false;
         try {
-            requests = this.prepareRequests(adapterContext);
+            queryContexts = this.prepareRequests(executionContext);
             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';
+            for (const context of queryContexts) {
+                exclusive = exclusive || context.query.operationType !== 'read';
                 // Wait previous read requests before executing update request
                 if (exclusive && 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) {
@@ -40,10 +40,14 @@ class OpraAdapter {
                     continue;
                 }
                 try {
+                    const resource = context.query.resource;
                     const promise = (async () => {
                         await resource.prepare(context);
-                        if (userContextResolver && !userContext)
-                            userContext = userContextResolver(this.isBatch(adapterContext));
+                        if (this.userContextResolver && !userContext)
+                            userContext = this.userContextResolver({
+                                executionContext,
+                                isBatch: this.isBatch(executionContext)
+                            });
                         context.userContext = userContext;
                         await resource.execute(context);
                     })().catch(e => {
@@ -69,22 +73,21 @@ class OpraAdapter {
             }
             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);
+            await this.sendResponse(executionContext, queryContexts);
         }
         catch (e) {
+            failed = true;
             const error = (0, wrap_error_js_1.wrapError)(e);
-            await this.sendError(adapterContext, error);
-            return;
+            await this.sendError(executionContext, error);
+        }
+        finally {
+            if (executionContext instanceof strict_typed_events_1.AsyncEventEmitter) {
+                await executionContext
+                    .emitAsyncSerial('finish', {
+                    userContext,
+                    failed
+                }).catch();
+            }
         }
     }
     static async initI18n(options) {

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

@@ -1,29 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpraExpressAdapter = void 0;
+const strict_typed_events_1 = require("strict-typed-events");
 const url_1 = require("@opra/url");
 const http_adapter_js_1 = require("./http-adapter.js");
 class OpraExpressAdapter extends http_adapter_js_1.OpraHttpAdapter {
     static async init(app, service, options) {
         const i18n = await this.initI18n(options);
-        const adapter = new OpraExpressAdapter(service, i18n);
+        const adapter = new OpraExpressAdapter(service, {
+            ...options,
+            i18n
+        });
         const prefix = '/' + (0, url_1.normalizePath)(options?.prefix, true);
-        const userContextResolver = options?.userContext;
         app.use(prefix, (request, response, next) => {
             (async () => {
-                const req = new ExpressRequestWrapper(request);
-                const res = new ExpressResponseWrapper(response);
-                const adapterContext = {
-                    getRequest: () => req,
-                    getResponse: () => res
-                };
-                await adapter.handler(adapterContext, (isBatch) => userContextResolver && userContextResolver(request, { platform: 'express', isBatch }));
+                const executionContext = new ExpressExecutionContext(request, response);
+                await adapter.handler(executionContext);
             })().catch(e => next(e));
         });
         return adapter;
     }
 }
 exports.OpraExpressAdapter = OpraExpressAdapter;
+class ExpressExecutionContext extends strict_typed_events_1.AsyncEventEmitter {
+    _request;
+    _response;
+    constructor(request, response) {
+        super();
+        this._request = new ExpressRequestWrapper(request);
+        this._response = new ExpressResponseWrapper(response);
+    }
+    getType() {
+        return 'http';
+    }
+    getPlatform() {
+        return 'express';
+    }
+    switchToHttp() {
+        return this;
+    }
+    getRequest() {
+        return this._request.getInstance();
+    }
+    getResponse() {
+        return this._response.getInstance();
+    }
+    getRequestWrapper() {
+        return this._request;
+    }
+    getResponseWrapper() {
+        return this._response;
+    }
+    onFinish(fn) {
+        this.on('finish', fn);
+    }
+}
 class ExpressRequestWrapper {
     instance;
     constructor(instance) {

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

@@ -6,26 +6,26 @@ 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 query_interface_js_1 = require("../../interfaces/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 query_context_js_1 = require("../query-context.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 {
-    prepareRequests(adapterContext) {
-        const req = adapterContext.getRequest();
+    prepareRequests(executionContext) {
+        const req = executionContext.getRequestWrapper();
         // todo implement batch requests
-        if (this.isBatch(adapterContext)) {
+        if (this.isBatch(executionContext)) {
             throw new Error('not implemented yet');
         }
         const url = new url_1.OpraURL(req.getUrl());
         return [
-            this.prepareRequest(adapterContext, url, req.getMethod(), headers_js_1.Headers.from(req.getHeaders()), req.getBody())
+            this.prepareRequest(executionContext, url, req.getMethod(), headers_js_1.Headers.from(req.getHeaders()), req.getBody())
         ];
     }
-    prepareRequest(adapterContext, url, method, headers, body) {
+    prepareRequest(executionContext, url, method, headers, body) {
         if (!url.path.size)
             throw new index_js_2.BadRequestError();
         if (method !== 'GET' && url.path.size > 1)
@@ -35,20 +35,13 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
             throw new index_js_2.MethodNotAllowedError({
                 message: `Method "${method}" is not allowed by target resource`
             });
-        return new execution_context_js_1.ExecutionRequest({
+        return new query_context_js_1.QueryContext({
+            service: this.service,
+            executionContext,
             query,
             headers,
             params: url.searchParams,
-        });
-    }
-    createExecutionContext(adapterContext, request) {
-        return new execution_context_js_1.ExecutionContext({
-            type: 'http',
-            service: this.service,
-            request,
-            response: new execution_context_js_1.ExecutionResponse(),
-            adapterContext,
-            continueOnError: request.query.operationType === 'read'
+            continueOnError: query.operationType === 'read'
         });
     }
     buildQuery(url, method, body) {
@@ -73,7 +66,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                         switch (method) {
                             case 'GET': {
                                 if (scope === 'collection') {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forSearch(resource, {
+                                    query = query_interface_js_1.OpraQuery.forSearch(resource, {
                                         filter: url.searchParams.get('$filter'),
                                         limit: url.searchParams.get('$limit'),
                                         skip: url.searchParams.get('$skip'),
@@ -86,7 +79,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                                     });
                                 }
                                 else {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forGet(resource, p.key, {
+                                    query = query_interface_js_1.OpraQuery.forGet(resource, p.key, {
                                         pick: url.searchParams.get('$pick'),
                                         omit: url.searchParams.get('$omit'),
                                         include: url.searchParams.get('$include')
@@ -105,7 +98,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.forGetProperty(prop);
+                                        const q = query_interface_js_1.OpraQuery.forGetProperty(prop);
                                         if (nested) {
                                             nested.nested = q;
                                         }
@@ -119,18 +112,18 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                             }
                             case 'DELETE': {
                                 if (scope === 'collection') {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forDeleteMany(resource, {
+                                    query = query_interface_js_1.OpraQuery.forDeleteMany(resource, {
                                         filter: url.searchParams.get('$filter'),
                                     });
                                 }
                                 else {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forDelete(resource, p.key);
+                                    query = query_interface_js_1.OpraQuery.forDelete(resource, p.key);
                                 }
                                 break;
                             }
                             case 'POST': {
                                 if (scope === 'collection') {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forCreate(resource, body, {
+                                    query = query_interface_js_1.OpraQuery.forCreate(resource, body, {
                                         pick: url.searchParams.get('$pick'),
                                         omit: url.searchParams.get('$omit'),
                                         include: url.searchParams.get('$include')
@@ -140,12 +133,12 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
                             }
                             case 'PATCH': {
                                 if (scope === 'collection') {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forUpdateMany(resource, body, {
+                                    query = query_interface_js_1.OpraQuery.forUpdateMany(resource, body, {
                                         filter: url.searchParams.get('$filter')
                                     });
                                 }
                                 else {
-                                    query = execution_query_interface_js_1.ExecutionQuery.forUpdate(resource, p.key, body, {
+                                    query = query_interface_js_1.OpraQuery.forUpdate(resource, p.key, body, {
                                         pick: url.searchParams.get('$pick'),
                                         omit: url.searchParams.get('$omit'),
                                         include: url.searchParams.get('$include')
@@ -166,13 +159,13 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
             throw new index_js_2.BadRequestError({ message: e.message });
         }
     }
-    async sendResponse(adapterContext, executionContexts) {
+    async sendResponse(executionContext, queryContexts) {
         const outputPackets = [];
-        for (const ctx of executionContexts) {
+        for (const ctx of queryContexts) {
             const v = this.createOutput(ctx);
             outputPackets.push(v);
         }
-        if (this.isBatch(adapterContext)) {
+        if (this.isBatch(executionContext)) {
             // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
             return;
         }
@@ -186,7 +179,7 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
             });
         }
         const out = outputPackets[0];
-        const resp = adapterContext.getResponse();
+        const resp = executionContext.getResponseWrapper();
         resp.setStatus(out.status);
         resp.setHeader(index_js_1.HttpHeaders.Content_Type, 'application/json');
         resp.setHeader(index_js_1.HttpHeaders.Cache_Control, 'no-cache');
@@ -201,11 +194,11 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
         resp.send(JSON.stringify(out.body));
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    isBatch(adapterContext) {
+    isBatch(executionContext) {
         return false;
     }
     createOutput(ctx) {
-        const { query } = ctx.request;
+        const { query } = ctx;
         let status = ctx.response.status;
         let body = ctx.response.value || {};
         const errors = ctx.response.errors?.map(e => (0, wrap_error_js_1.wrapError)(e));
@@ -231,8 +224,8 @@ class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
             body
         };
     }
-    async sendError(adapterContext, error) {
-        const resp = adapterContext.getResponse();
+    async sendError(executionContext, error) {
+        const resp = executionContext.getResponseWrapper();
         resp.setStatus(error.status || 500);
         resp.setHeader(index_js_1.HttpHeaders.Content_Type, 'application/json');
         resp.setHeader(index_js_1.HttpHeaders.Cache_Control, 'no-cache');