@opra/core 0.0.8 → 0.0.11

package/cjs/exception/api-exception.js

@@ -13,12 +13,26 @@ 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);
+        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';
+        if (this.cause instanceof Error && this.cause.stack) {
+            if (ApiException.stackAsDiagnostics)
+                this.response.diagnostics = this.cause.stack.split('\n');
+            this.stack = this.cause.stack;
+        }
     }
     setStatus(status) {
         this.status = status;
@@ -27,37 +41,20 @@ class ApiException extends Error {
     _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 (!this.response.severity)
-            if (this.status >= 500)
-                this.response.severity = 'fatal';
-            else
-                this.response.severity = 'error';
+    _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)

package/cjs/exception/{errors → http-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({
-            message: (0, i18n_1.translate)('error:BAD_REQUEST', 'Bad request'),
+        super(response, cause);
+        this.status = index_js_1.HttpStatus.BAD_REQUEST;
+    }
+    _initResponse(response) {
+        super._initResponse({
+            message: (0, i18n_1.translate)('error:BAD_REQUEST'),
             severity: 'error',
             code: 'BAD_REQUEST',
             ...response
-        }, cause);
-        this.status = index_js_1.HttpStatus.BAD_REQUEST;
+        });
     }
 }
 exports.BadRequestError = BadRequestError;

package/cjs/exception/{errors → http-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({
-            message: (0, i18n_1.translate)('error:FAILED_DEPENDENCY', 'The request failed due to failure of a previous request.'),
+        super(response, cause);
+        this.status = index_js_1.HttpStatus.FAILED_DEPENDENCY;
+    }
+    _initResponse(response) {
+        super._initResponse({
+            message: (0, i18n_1.translate)('error:FAILED_DEPENDENCY'),
             severity: 'error',
             code: 'FAILED_DEPENDENCY',
             ...response
-        }, cause);
-        this.status = index_js_1.HttpStatus.FAILED_DEPENDENCY;
+        });
     }
 }
 exports.FailedDependencyError = FailedDependencyError;

package/cjs/exception/{errors → http-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({
-            message: (0, i18n_1.translate)('error:FORBIDDEN', 'Forbidden'),
+        super(response, cause);
+        this.status = index_js_1.HttpStatus.FORBIDDEN;
+    }
+    _initResponse(response) {
+        super._initResponse({
+            message: (0, i18n_1.translate)('error:FORBIDDEN'),
             severity: 'error',
             code: 'FORBIDDEN',
             ...response
-        }, cause);
-        this.status = index_js_1.HttpStatus.FORBIDDEN;
+        });
     }
 }
 exports.ForbiddenError = ForbiddenError;

package/cjs/exception/{errors → http-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({
-            message: (0, i18n_1.translate)('error:INTERNAL_SERVER_ERROR', 'Internal server error'),
+        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'),
             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 → http-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({
-            message: (0, i18n_1.translate)('error:METHOD_NOT_ALLOWED', 'Method Not Allowed'),
+        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'),
             severity: 'error',
             code: 'METHOD_NOT_ALLOWED',
             ...response
-        }, cause);
-        this.status = index_js_1.HttpStatus.METHOD_NOT_ALLOWED;
+        });
     }
 }
 exports.MethodNotAllowedError = MethodNotAllowedError;

package/cjs/exception/{errors → http-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 → http-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 → http-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({
-            message: (0, i18n_1.translate)('error:UNPROCESSABLE_ENTITY', 'Unprocessable entity'),
+        super(response, cause);
+        this.status = index_js_1.HttpStatus.UNPROCESSABLE_ENTITY;
+    }
+    _initResponse(response) {
+        super._initResponse({
+            message: (0, i18n_1.translate)('error:UNPROCESSABLE_ENTITY'),
             severity: 'error',
             code: 'UNPROCESSABLE_ENTITY',
             ...response
-        }, cause);
-        this.status = index_js_1.HttpStatus.UNPROCESSABLE_ENTITY;
+        });
     }
 }
 exports.UnprocessableEntityError = UnprocessableEntityError;

package/cjs/exception/index.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./api-exception.js"), exports);
-tslib_1.__exportStar(require("./errors/bad-request.error.js"), exports);
-tslib_1.__exportStar(require("./errors/failed-dependency.error.js"), exports);
-tslib_1.__exportStar(require("./errors/internal-server.error.js"), exports);
-tslib_1.__exportStar(require("./errors/method-not-allowed.error.js"), exports);
-tslib_1.__exportStar(require("./errors/not-found.error.js"), exports);
-tslib_1.__exportStar(require("./errors/unauthorized.error.js"), exports);
-tslib_1.__exportStar(require("./errors/unprocessable-entity.error.js"), exports);
+tslib_1.__exportStar(require("./http-errors/bad-request.error.js"), exports);
+tslib_1.__exportStar(require("./http-errors/failed-dependency.error.js"), exports);
+tslib_1.__exportStar(require("./http-errors/forbidden.error.js"), exports);
+tslib_1.__exportStar(require("./http-errors/internal-server.error.js"), exports);
+tslib_1.__exportStar(require("./http-errors/method-not-allowed.error.js"), exports);
+tslib_1.__exportStar(require("./http-errors/not-found.error.js"), exports);
+tslib_1.__exportStar(require("./http-errors/unauthorized.error.js"), exports);
+tslib_1.__exportStar(require("./http-errors/unprocessable-entity.error.js"), exports);
+tslib_1.__exportStar(require("./resource-errors/resource-conflict.error.js"), exports);

package/cjs/exception/resource-errors/resource-conflict.error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceConflictError = void 0;
+const i18n_1 = require("@opra/i18n");
+const index_js_1 = require("../../enums/index.js");
+const api_exception_js_1 = require("../api-exception.js");
+class ResourceConflictError extends api_exception_js_1.ApiException {
+    constructor(resource, fields, cause) {
+        super({
+            message: (0, i18n_1.translate)(`error:RESOURCE_CONFLICT`, { resource, fields }),
+            severity: 'error',
+            code: 'RESOURCE_CONFLICT',
+            subject: resource,
+            location: fields
+        }, cause);
+        this.status = index_js_1.HttpStatus.CONFLICT;
+    }
+}
+exports.ResourceConflictError = ResourceConflictError;

package/cjs/exception/wrap-error.js

@@ -2,7 +2,7 @@
 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");
+const internal_server_error_js_1 = require("./http-errors/internal-server.error.js");
 function wrapError(response) {
     if (response instanceof api_exception_js_1.ApiException)
         return response;
@@ -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,39 @@
 "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");
+const create_i18n_js_1 = require("../../utils/create-i18n.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.operation !== '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 +41,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 +74,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) {
@@ -92,9 +96,7 @@ class OpraAdapter {
             return options.i18n;
         if (typeof options?.i18n === 'function')
             return options.i18n();
-        const instance = i18n_1.I18n.createInstance(options?.i18n);
-        await instance.init();
-        return instance;
+        return (0, create_i18n_js_1.createI18n)(options?.i18n);
     }
 }
 exports.OpraAdapter = OpraAdapter;

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) {