@opra/core 0.0.8 → 0.0.11

package/cjs/utils/internal-data-types.js

@@ -1,44 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.internalDataTypes = exports.primitiveDataTypeNames = exports.builtinClassMap = void 0;
+exports.internalDataTypes = exports.builtinClassMap = exports.primitiveDataTypeNames = void 0;
+exports.primitiveDataTypeNames = ['boolean', 'number', 'string', 'null'];
 exports.builtinClassMap = new Map();
-exports.builtinClassMap.set(Boolean, 'boolean');
-exports.builtinClassMap.set(Number, 'number');
-exports.builtinClassMap.set(String, 'string');
-exports.builtinClassMap.set(Buffer, 'buffer');
-exports.primitiveDataTypeNames = ['boolean', 'number', 'integer', 'string'];
 exports.internalDataTypes = new Map();
 const internalDataTypeArray = [
     {
         kind: 'SimpleType',
         name: 'boolean',
         type: 'boolean',
-        description: 'Simple true/false value'
+        description: 'Simple true/false value',
+        ctor: Boolean
+    },
+    {
+        kind: 'SimpleType',
+        name: 'string',
+        type: 'string',
+        description: 'A sequence of characters',
+        ctor: String
     },
     {
         kind: 'SimpleType',
         name: 'number',
         type: 'number',
-        description: 'Both Integer as well as Floating-Point numbers'
+        description: 'Both Integer as well as Floating-Point numbers',
+        ctor: Number
     },
     {
         kind: 'SimpleType',
-        name: 'string',
-        type: 'string',
-        description: 'A sequence of characters'
+        name: 'integer',
+        type: 'number',
+        base: 'number',
+        description: 'Integer number',
+        ctor: Number
     },
     {
         kind: 'ComplexType',
         name: 'object',
         description: 'Object type with additional properties',
-        additionalProperties: true
+        additionalProperties: true,
+        ctor: Object
     },
     {
         kind: 'SimpleType',
-        name: 'integer',
-        type: 'number',
-        base: 'number',
-        description: 'Integer number'
+        name: 'date',
+        type: 'string',
+        description: 'Date',
+        format: 'date',
+        ctor: Date
+    },
+    {
+        kind: 'SimpleType',
+        name: 'date-time',
+        type: 'string',
+        description: 'Date time value',
+        format: 'date-time',
+        ctor: Date
+    },
+    {
+        kind: 'SimpleType',
+        name: 'time',
+        type: 'string',
+        description: 'Time value',
+        format: 'time',
+        ctor: String
+    },
+    {
+        kind: 'SimpleType',
+        name: 'buffer',
+        type: 'string',
+        description: 'Buffer value',
+        format: 'base64',
+        ctor: Buffer
     }
 ];
-internalDataTypeArray.forEach(sch => exports.internalDataTypes.set(sch.name, sch));
+internalDataTypeArray.forEach(sch => {
+    exports.internalDataTypes.set(sch.name, sch);
+    if (sch.ctor && !exports.builtinClassMap.has(sch.ctor))
+        exports.builtinClassMap.set(sch.ctor, sch);
+});

package/esm/exception/api-exception.d.ts

@@ -31,9 +31,10 @@ export declare class ApiException extends Error {
     response: ErrorResponse;
     status: number;
     cause?: Error;
-    constructor(response: string | ErrorResponse | Error, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
     setStatus(status: number | HttpStatus): this;
     protected _initName(): void;
-    protected _initResponse(init: string | ErrorResponse | Error): void;
+    protected _initErrorInstance(init: Error): void;
+    protected _initResponse(response?: Partial<ErrorResponse>): void;
     static wrap(response: string | ErrorResponse | Error): ApiException;
 }

package/esm/exception/api-exception.js

@@ -10,12 +10,26 @@ export class ApiException extends Error {
     constructor(response, cause) {
         super('');
         this._initName();
+        this.status = 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 = 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;
@@ -24,37 +38,20 @@ export 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/esm/exception/{errors → http-errors}/bad-request.error.d.ts

@@ -5,5 +5,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
  */
 export declare class BadRequestError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/{errors → http-errors}/bad-request.error.js

@@ -8,12 +8,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class BadRequestError extends ApiException {
     constructor(response, cause) {
-        super({
-            message: translate('error:BAD_REQUEST', 'Bad request'),
+        super(response, cause);
+        this.status = HttpStatus.BAD_REQUEST;
+    }
+    _initResponse(response) {
+        super._initResponse({
+            message: translate('error:BAD_REQUEST'),
             severity: 'error',
             code: 'BAD_REQUEST',
             ...response
-        }, cause);
-        this.status = HttpStatus.BAD_REQUEST;
+        });
     }
 }

package/esm/exception/{errors → http-errors}/failed-dependency.error.d.ts

@@ -4,5 +4,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * The request failed due to failure of a previous request.
  */
 export declare class FailedDependencyError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/{errors → http-errors}/failed-dependency.error.js

@@ -7,12 +7,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class FailedDependencyError extends ApiException {
     constructor(response, cause) {
-        super({
-            message: translate('error:FAILED_DEPENDENCY', 'The request failed due to failure of a previous request.'),
+        super(response, cause);
+        this.status = HttpStatus.FAILED_DEPENDENCY;
+    }
+    _initResponse(response) {
+        super._initResponse({
+            message: translate('error:FAILED_DEPENDENCY'),
             severity: 'error',
             code: 'FAILED_DEPENDENCY',
             ...response
-        }, cause);
-        this.status = HttpStatus.FAILED_DEPENDENCY;
+        });
     }
 }

package/esm/exception/{errors → http-errors}/forbidden.error.d.ts

@@ -6,5 +6,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * the client's identity is known to the server.
  */
 export declare class ForbiddenError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/{errors → http-errors}/forbidden.error.js

@@ -9,12 +9,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class ForbiddenError extends ApiException {
     constructor(response, cause) {
-        super({
-            message: translate('error:FORBIDDEN', 'Forbidden'),
+        super(response, cause);
+        this.status = HttpStatus.FORBIDDEN;
+    }
+    _initResponse(response) {
+        super._initResponse({
+            message: translate('error:FORBIDDEN'),
             severity: 'error',
             code: 'FORBIDDEN',
             ...response
-        }, cause);
-        this.status = HttpStatus.FORBIDDEN;
+        });
     }
 }

package/esm/exception/{errors → http-errors}/internal-server.error.d.ts

@@ -4,5 +4,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * The server has encountered a situation it does not know how to handle.
  */
 export declare class InternalServerError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/{errors → http-errors}/internal-server.error.js

@@ -1,3 +1,4 @@
+import _ from 'lodash';
 import { translate } from '@opra/i18n';
 import { HttpStatus } from '../../enums/index.js';
 import { ApiException } from '../api-exception.js';
@@ -7,12 +8,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class InternalServerError extends ApiException {
     constructor(response, cause) {
-        super({
-            message: translate('error:INTERNAL_SERVER_ERROR', 'Internal server error'),
+        super(response, cause);
+        this.status = HttpStatus.INTERNAL_SERVER_ERROR;
+    }
+    _initResponse(response) {
+        super._initResponse({
+            message: translate('error:INTERNAL_SERVER_ERROR'),
             severity: 'error',
             code: 'INTERNAL_SERVER_ERROR',
-            ...response
-        }, cause);
-        this.status = HttpStatus.INTERNAL_SERVER_ERROR;
+            ..._.omitBy(response, _.isNil)
+        });
     }
 }

package/esm/exception/{errors → http-errors}/method-not-allowed.error.d.ts

@@ -5,5 +5,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * For example, an API may not allow calling DELETE to remove a resource.
  */
 export declare class MethodNotAllowedError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/{errors → http-errors}/method-not-allowed.error.js

@@ -8,12 +8,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class MethodNotAllowedError extends ApiException {
     constructor(response, cause) {
-        super({
-            message: translate('error:METHOD_NOT_ALLOWED', 'Method Not Allowed'),
+        super(response, cause);
+        this.status = HttpStatus.METHOD_NOT_ALLOWED;
+    }
+    _initResponse(response) {
+        super._initResponse({
+            message: translate('error:METHOD_NOT_ALLOWED'),
             severity: 'error',
             code: 'METHOD_NOT_ALLOWED',
             ...response
-        }, cause);
-        this.status = HttpStatus.METHOD_NOT_ALLOWED;
+        });
     }
 }

package/esm/exception/{errors → http-errors}/not-found.error.d.ts

@@ -8,5 +8,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * frequent occurrence on the web.
  */
 export declare class NotFoundError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/{errors → http-errors}/not-found.error.js

@@ -11,12 +11,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class NotFoundError extends ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = HttpStatus.NOT_FOUND;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: translate('error:NOT_FOUND', 'Not found'),
             severity: 'error',
             code: 'NOT_FOUND',
             ...response
-        }, cause);
-        this.status = HttpStatus.NOT_FOUND;
+        });
     }
 }

package/esm/exception/{errors → http-errors}/unauthorized.error.d.ts

@@ -5,5 +5,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * That is, the client must authenticate itself to get the requested response.
  */
 export declare class UnauthorizedError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/{errors → http-errors}/unauthorized.error.js

@@ -8,12 +8,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class UnauthorizedError extends ApiException {
     constructor(response, cause) {
-        super({
+        super(response, cause);
+        this.status = HttpStatus.UNAUTHORIZED;
+    }
+    _initResponse(response) {
+        super._initResponse({
             message: translate('error:UNAUTHORIZED', 'Unauthorized'),
             severity: 'error',
             code: 'UNAUTHORIZED',
             ...response
-        }, cause);
-        this.status = HttpStatus.UNAUTHORIZED;
+        });
     }
 }

package/esm/exception/{errors → http-errors}/unprocessable-entity.error.d.ts

@@ -4,5 +4,6 @@ import { ApiException, ErrorResponse } from '../api-exception.js';
  * The request was well-formed but was unable to be followed due to semantic errors.
  */
 export declare class UnprocessableEntityError extends ApiException {
-    constructor(response?: ErrorResponse, cause?: Error);
+    constructor(response?: string | ErrorResponse | Error, cause?: Error);
+    protected _initResponse(response: Partial<ErrorResponse>): void;
 }

package/esm/exception/{errors → http-errors}/unprocessable-entity.error.js

@@ -7,12 +7,15 @@ import { ApiException } from '../api-exception.js';
  */
 export class UnprocessableEntityError extends ApiException {
     constructor(response, cause) {
-        super({
-            message: translate('error:UNPROCESSABLE_ENTITY', 'Unprocessable entity'),
+        super(response, cause);
+        this.status = HttpStatus.UNPROCESSABLE_ENTITY;
+    }
+    _initResponse(response) {
+        super._initResponse({
+            message: translate('error:UNPROCESSABLE_ENTITY'),
             severity: 'error',
             code: 'UNPROCESSABLE_ENTITY',
             ...response
-        }, cause);
-        this.status = HttpStatus.UNPROCESSABLE_ENTITY;
+        });
     }
 }

package/esm/exception/index.d.ts

@@ -1,8 +1,10 @@
 export * from './api-exception.js';
-export * from './errors/bad-request.error.js';
-export * from './errors/failed-dependency.error.js';
-export * from './errors/internal-server.error.js';
-export * from './errors/method-not-allowed.error.js';
-export * from './errors/not-found.error.js';
-export * from './errors/unauthorized.error.js';
-export * from './errors/unprocessable-entity.error.js';
+export * from './http-errors/bad-request.error.js';
+export * from './http-errors/failed-dependency.error.js';
+export * from './http-errors/forbidden.error.js';
+export * from './http-errors/internal-server.error.js';
+export * from './http-errors/method-not-allowed.error.js';
+export * from './http-errors/not-found.error.js';
+export * from './http-errors/unauthorized.error.js';
+export * from './http-errors/unprocessable-entity.error.js';
+export * from './resource-errors/resource-conflict.error.js';

package/esm/exception/index.js

@@ -1,8 +1,10 @@
 export * from './api-exception.js';
-export * from './errors/bad-request.error.js';
-export * from './errors/failed-dependency.error.js';
-export * from './errors/internal-server.error.js';
-export * from './errors/method-not-allowed.error.js';
-export * from './errors/not-found.error.js';
-export * from './errors/unauthorized.error.js';
-export * from './errors/unprocessable-entity.error.js';
+export * from './http-errors/bad-request.error.js';
+export * from './http-errors/failed-dependency.error.js';
+export * from './http-errors/forbidden.error.js';
+export * from './http-errors/internal-server.error.js';
+export * from './http-errors/method-not-allowed.error.js';
+export * from './http-errors/not-found.error.js';
+export * from './http-errors/unauthorized.error.js';
+export * from './http-errors/unprocessable-entity.error.js';
+export * from './resource-errors/resource-conflict.error.js';

package/esm/exception/resource-errors/resource-conflict.error.d.ts

@@ -0,0 +1,4 @@
+import { ApiException } from '../api-exception.js';
+export declare class ResourceConflictError extends ApiException {
+    constructor(resource: string, fields: string | string[], cause?: Error);
+}

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

@@ -0,0 +1,15 @@
+import { translate } from '@opra/i18n';
+import { HttpStatus } from '../../enums/index.js';
+import { ApiException } from '../api-exception.js';
+export class ResourceConflictError extends ApiException {
+    constructor(resource, fields, cause) {
+        super({
+            message: translate(`error:RESOURCE_CONFLICT`, { resource, fields }),
+            severity: 'error',
+            code: 'RESOURCE_CONFLICT',
+            subject: resource,
+            location: fields
+        }, cause);
+        this.status = HttpStatus.CONFLICT;
+    }
+}

package/esm/exception/wrap-error.js

@@ -1,5 +1,5 @@
 import { ApiException } from './api-exception.js';
-import { InternalServerError } from './errors/internal-server.error.js';
+import { InternalServerError } from './http-errors/internal-server.error.js';
 export function wrapError(response) {
     if (response instanceof ApiException)
         return response;
@@ -7,7 +7,7 @@ export function wrapError(response) {
         const x = response;
         if (typeof x.status === 'number' || typeof x.getStatus === 'function')
             return new ApiException(response);
-        return new InternalServerError(undefined, response);
+        return new InternalServerError(response);
     }
     return new InternalServerError();
 }

package/esm/implementation/adapter/adapter.d.ts

@@ -1,14 +1,21 @@
 import { FallbackLng, I18n, LanguageResource } from '@opra/i18n';
 import { ApiException } from '../../exception/index.js';
-import { ExecutionContext, ExecutionRequest } from '../execution-context.js';
+import { IExecutionContext } from '../../interfaces/execution-context.interface.js';
 import { OpraService } from '../opra-service.js';
+import { QueryContext } from '../query-context.js';
 export declare namespace OpraAdapter {
+    type UserContextResolver = (args: {
+        executionContext: IExecutionContext;
+        isBatch: boolean;
+    }) => object | Promise<object>;
+    type RequestFinishEvent = (args: {
+        executionContext: IExecutionContext;
+        userContext?: any;
+        failed: boolean;
+    }) => Promise<void>;
     interface Options {
         i18n?: I18n | I18nOptions | (() => Promise<I18n>);
-        userContext?: (request: any, options: {
-            platform: string;
-            isBatch: boolean;
-        }) => object | Promise<object>;
+        userContext?: UserContextResolver;
     }
     interface I18nOptions {
         /**
@@ -37,17 +44,18 @@ export declare namespace OpraAdapter {
          */
         resourceDirs?: string[];
     }
-    type UserContextResolver = (isBatch: boolean) => any | Promise<any>;
 }
-export declare abstract class OpraAdapter<TAdapterContext = any> {
+export declare abstract class OpraAdapter<TExecutionContext extends IExecutionContext> {
     readonly service: OpraService;
     readonly i18n: I18n;
-    constructor(service: OpraService, i18n?: I18n);
-    protected abstract prepareRequests(adapterContext: TAdapterContext): ExecutionRequest[];
-    protected abstract createExecutionContext(adapterContext: any, request: ExecutionRequest): ExecutionContext;
-    protected abstract sendResponse(adapterContext: TAdapterContext, executionContexts: ExecutionContext[]): Promise<void>;
-    protected abstract sendError(adapterContext: TAdapterContext, error: ApiException): Promise<void>;
-    protected abstract isBatch(adapterContext: TAdapterContext): boolean;
-    protected handler(adapterContext: TAdapterContext, userContextResolver?: OpraAdapter.UserContextResolver): Promise<void>;
+    readonly userContextResolver?: OpraAdapter.UserContextResolver;
+    constructor(service: OpraService, options?: Omit<OpraAdapter.Options, 'i18n'> & {
+        i18n: I18n;
+    });
+    protected abstract prepareRequests(executionContext: TExecutionContext): QueryContext[];
+    protected abstract sendResponse(executionContext: TExecutionContext, queryContexts: QueryContext[]): Promise<void>;
+    protected abstract sendError(executionContext: TExecutionContext, error: ApiException): Promise<void>;
+    protected abstract isBatch(executionContext: TExecutionContext): boolean;
+    protected handler(executionContext: TExecutionContext): Promise<void>;
     protected static initI18n(options?: OpraAdapter.Options): Promise<I18n>;
 }