@opra/core 0.25.4 → 0.26.0

package/esm/index.js

@@ -1,22 +1,23 @@
 import "reflect-metadata";
 import './augmentation/resource.augmentation.js';
 import './augmentation/collection.augmentation.js';
+import './augmentation/container.augmentation.js';
 import './augmentation/singleton.augmentation.js';
 import './augmentation/storage.augmentation.js';
 export * from './types.js';
-export * from './adapter/execution-context.js';
-export * from './adapter/endpoint-context.js';
-export * from './adapter/platform-adapter.js';
-export * from './adapter/request.js';
-export * from './adapter/response.js';
-export * from './adapter/http/express-adapter.js';
-export * from './adapter/http/http-adapter.js';
-export * from './adapter/http/impl/http-incoming-message.host.js';
-export * from './adapter/http/impl/http-outgoing-message.host.js';
-export * from './adapter/http/http-server-request.js';
-export * from './adapter/http/http-server-response.js';
-export * from './adapter/http/helpers/multipart-helper.js';
-export * from './adapter/interfaces/interceptor.interface.js';
-export * from './adapter/interfaces/logger.interface.js';
-export * from './adapter/interfaces/request-handler.interface.js';
-export * from './adapter/services/logger.js';
+export * from './execution-context.js';
+export * from './request-context.js';
+export * from './platform-adapter.js';
+export * from './request.js';
+export * from './response.js';
+export * from './http/adapters/express-adapter.js';
+export * from './http/adapters/node-http-adapter.js';
+export * from './http/impl/http-incoming-message.host.js';
+export * from './http/impl/http-outgoing-message.host.js';
+export * from './http/http-server-request.js';
+export * from './http/http-server-response.js';
+export * from './http/helpers/multipart-helper.js';
+export * from './interfaces/interceptor.interface.js';
+export * from './interfaces/logger.interface.js';
+export * from './interfaces/request-handler.interface.js';
+export * from './services/logger.js';

package/esm/platform-adapter.host.js

@@ -0,0 +1,132 @@
+import path from 'path';
+import { pascalCase } from 'putil-varhelpers';
+import { AsyncEventEmitter } from 'strict-typed-events';
+import { Container, CrudResource, ForbiddenError, getStackFileName, I18n, Resource, translate } from '@opra/common';
+import { Logger } from './services/logger.js';
+const resourceInitialized = Symbol.for('opra.resource.initialized');
+/**
+ * @class PlatformAdapterHost
+ */
+export class PlatformAdapterHost extends AsyncEventEmitter {
+    constructor() {
+        super(...arguments);
+        this._controllers = new Map();
+    }
+    get api() {
+        return this._api;
+    }
+    get platform() {
+        return this._platform;
+    }
+    get protocol() {
+        return this._protocol;
+    }
+    get serviceName() {
+        return this._serviceName;
+    }
+    get i18n() {
+        return this._i18n;
+    }
+    async close() {
+        const promises = [];
+        for (const r of this._controllers.values()) {
+            const onShutdown = r?.onShutdown;
+            if (onShutdown)
+                promises.push((async () => onShutdown.call(r.controller, r))());
+        }
+        await Promise.allSettled(promises);
+        this._controllers.clear();
+    }
+    /**
+     * Initializes the adapter
+     */
+    async init(api, options) {
+        if (this._api)
+            throw new Error(`Already initialized`);
+        this._api = api;
+        this._interceptors = [...(options?.interceptors || [])];
+        this._logger = options?.logger && options.logger instanceof Logger
+            ? options.logger
+            : new Logger({ instance: options?.logger });
+        // Assign events
+        if (options?.on) {
+            for (const [event, fn] of Object.entries(options.on)) {
+                /* istanbul ignore next */
+                if (typeof fn === 'function')
+                    this.on(event, fn);
+            }
+        }
+        // Make a safe service name
+        this._serviceName = pascalCase((api.info.title || '').replace(/[^a-z0-9_ ]/ig, '')) || 'OpraService';
+        if (!/^[a-z]/i.test(this._serviceName))
+            this._serviceName = 'X' + this._serviceName;
+        // Init I18n
+        if (options?.i18n instanceof I18n)
+            this._i18n = options.i18n;
+        else if (typeof options?.i18n === 'function')
+            this._i18n = await options.i18n();
+        else
+            this._i18n = await this._createI18n(options?.i18n);
+        this._i18n = this._i18n || I18n.defaultInstance;
+        if (!this._i18n.isInitialized)
+            await this._i18n.init();
+        // Initialize all resources
+        await this.getController(this.api.root);
+    }
+    async getController(resource) {
+        resource = typeof resource === 'object' && resource instanceof Resource
+            ? resource : this.api.getResource(resource);
+        let controller = this._controllers.get(resource);
+        if (!controller) {
+            controller = resource.controller;
+            if (!controller && resource.ctor) {
+                controller = new resource.ctor();
+            }
+            this._controllers.set(resource, controller);
+        }
+        if (controller && !controller[resourceInitialized]) {
+            controller[resourceInitialized] = true;
+            // Initialize controller
+            if (typeof controller.onInit === 'function')
+                await controller.onInit.call(controller);
+            // Initialize sub resources of Container
+            if (resource instanceof Container) {
+                for (const r of resource.resources.values()) {
+                    await this.getController(r);
+                }
+            }
+        }
+        return controller;
+    }
+    async getOperationHandler(resource, operationOrAction) {
+        resource = typeof resource === 'object' && resource instanceof Resource
+            ? resource
+            : this.api.getResource(resource);
+        const controller = await this.getController(resource);
+        const endpoint = (resource instanceof CrudResource && resource.operations.get(operationOrAction)) ||
+            resource.actions.get(operationOrAction);
+        if (endpoint) {
+            const handler = typeof controller[operationOrAction] === 'function' ? controller[operationOrAction] : undefined;
+            if (handler)
+                return { controller, endpoint, handler };
+        }
+        throw new ForbiddenError({
+            message: translate('OPERATION_FORBIDDEN', { resource: resource.name, endpoint: operationOrAction }, `'{{resource}}' does not accept '{{endpoint}}' operations`),
+            severity: 'error',
+            code: 'OPERATION_FORBIDDEN'
+        });
+    }
+    async _createI18n(options) {
+        const opts = {
+            ...options,
+        };
+        delete opts.resourceDirs;
+        const instance = I18n.createInstance(opts);
+        await instance.init();
+        await instance.loadResourceDir(path.resolve(getStackFileName(), '../../../i18n'));
+        if (options?.resourceDirs)
+            for (const dir of options.resourceDirs)
+                await instance.loadResourceDir(dir);
+        return instance;
+    }
+}

package/esm/{adapter/endpoint-context.js → request-context.js}

@@ -1,5 +1,5 @@
-export var EndpointContext;
-(function (EndpointContext) {
+export var RequestContext;
+(function (RequestContext) {
     function from(executionContext, request, response) {
         const out = {
             request,
@@ -9,5 +9,5 @@ export var EndpointContext;
         Object.setPrototypeOf(out, executionContext);
         return out;
     }
-    EndpointContext.from = from;
-})(EndpointContext || (EndpointContext = {}));
+    RequestContext.from = from;
+})(RequestContext || (RequestContext = {}));

package/esm/{adapter/request.host.js → request.host.js}

@@ -3,6 +3,9 @@ export class RequestHost {
         Object.assign(this, init);
         this.params = this.params || {};
     }
+    get resource() {
+        return this.endpoint.resource;
+    }
     switchToHttp() {
         if (this.http)
             return this.http;

package/esm/response.js

@@ -0,0 +1 @@
+export {};

package/i18n/en/error.json

@@ -8,12 +8,11 @@
   "NOT_FOUND": "Not found",
   "UNAUTHORIZED": "You have not been authenticated to perform this action",
   "UNPROCESSABLE_ENTITY": "Unprocessable entity",
-  "SOURCE_NOT_FOUND": "Source not found",
   "REQUEST_VALIDATION": "Request validation failed",
   "RESPONSE_VALIDATION": "Response validation failed",
   "RESOURCE_NOT_FOUND": "Resource not found",
   "RESOURCE_CONFLICT": "There is already an other {{resource}} resource with same field values ({{fields}})",
-  "RESOLVER_FORBIDDEN": "The {{resource}} endpoint does not accept '{{endpoint}}' operations",
+  "OPERATION_FORBIDDEN": "The {{resource}} endpoint does not accept '{{endpoint}}' operations",
   "UNKNOWN_FIELD": "Unknown field '{{field}}'",
   "UNACCEPTED_SORT_FIELD": "Field '{{field}}' is not available for sort operation",
   "UNACCEPTED_FILTER_FIELD": "Field '{{field}}' is not available for filter operation",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.25.4",
+  "version": "0.26.0",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -27,7 +27,7 @@
     "clean:cover": "rimraf ../../coverage/core"
   },
   "dependencies": {
-    "@opra/common": "^0.25.4",
+    "@opra/common": "^0.26.0",
     "accepts": "^1.3.8",
     "content-disposition": "^0.5.4",
     "content-type": "^1.0.5",
@@ -65,7 +65,7 @@
     "@types/vary": "^1.1.0",
     "crypto-browserify": "^3.12.0",
     "path-browserify": "^1.0.1",
-    "ts-gems": "^2.4.1"
+    "ts-gems": "^2.5.0"
   },
   "type": "module",
   "module": "./esm/index.js",

package/types/augmentation/collection.augmentation.d.ts

@@ -1,50 +1,55 @@
 import type { PartialOutput } from '@opra/common';
-import type { EndpointContext } from '../adapter/endpoint-context.js';
-import type { Request as _Request } from '../adapter/request.js';
+import type { Request as _Request } from '../request.js';
+import type { RequestContext } from '../request-context';
 declare module "@opra/common" {
     namespace Collection {
         namespace Action {
+            interface Request extends _Request {
+                operation: 'action';
+                action: string;
+            }
             interface Context<TSession extends {} = {}> extends Resource.Context<TSession> {
-                key?: any;
             }
         }
         namespace Create {
             interface Request extends _Request {
-                endpoint: 'create';
+                operation: 'create';
                 data: any;
                 params: {
                     pick?: string[];
                     omit?: string[];
                     include?: string[];
+                    [key: string]: any;
                 };
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }
         namespace Delete {
             interface Request extends _Request {
-                endpoint: 'delete';
+                operation: 'delete';
                 key: any;
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }
         namespace DeleteMany {
             interface Request extends _Request {
-                endpoint: 'deleteMany';
+                operation: 'deleteMany';
                 params: {
                     filter?: any;
+                    [key: string]: any;
                 };
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }
         namespace FindMany {
             interface Request extends _Request {
-                endpoint: 'findMany';
+                operation: 'findMany';
                 params: {
                     filter?: any;
                     pick?: string[];
@@ -55,50 +60,54 @@ declare module "@opra/common" {
                     skip?: number;
                     distinct?: boolean;
                     count?: boolean;
+                    [key: string]: any;
                 };
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }
         namespace Get {
             interface Request extends _Request {
-                endpoint: 'get';
+                operation: 'get';
                 key: any;
                 params: {
                     pick?: string[];
                     omit?: string[];
                     include?: string[];
+                    [key: string]: any;
                 };
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }
         namespace Update {
             interface Request extends _Request {
-                endpoint: 'update';
+                operation: 'update';
                 key: any;
                 data: any;
                 params: {
                     pick?: string[];
                     omit?: string[];
                     include?: string[];
+                    [key: string]: any;
                 };
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }
         namespace UpdateMany {
             interface Request extends _Request {
-                endpoint: 'updateMany';
+                operation: 'updateMany';
                 data: any;
                 params: {
                     filter?: any;
+                    [key: string]: any;
                 };
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }

package/types/augmentation/container.augmentation.d.ts

@@ -0,0 +1,13 @@
+import type { Request as _Request } from '../request.js';
+declare module "@opra/common" {
+    namespace Container {
+        namespace Action {
+            interface Request extends _Request {
+                operation: 'action';
+                action: string;
+            }
+            interface Context<TSession extends {} = {}> extends Resource.Context<TSession> {
+            }
+        }
+    }
+}

package/types/augmentation/resource.augmentation.d.ts

@@ -1,4 +1,4 @@
-import { EndpointContext } from '../adapter/endpoint-context.js';
+import { RequestContext } from '../request-context.js';
 declare module "@opra/common" {
     interface CollectionConstructor {
         OnInit(): any;
@@ -9,7 +9,7 @@ declare module "@opra/common" {
         OnShutdown(): any;
     }
     namespace Resource {
-        interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+        interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
             params: Record<string, any>;
         }
     }

package/types/augmentation/singleton.augmentation.d.ts

@@ -1,15 +1,19 @@
 import type { PartialOutput } from '@opra/common';
-import type { EndpointContext } from '../adapter/endpoint-context.js';
-import type { Request as _Request } from '../adapter/request.js';
+import type { Request as _Request } from '../request.js';
+import type { RequestContext } from '../request-context.js';
 declare module "@opra/common" {
     namespace Singleton {
         namespace Action {
+            interface Request extends _Request {
+                operation: 'action';
+                action: string;
+            }
             interface Context<TSession extends {} = {}> extends Resource.Context<TSession> {
             }
         }
         namespace Create {
             interface Request extends _Request {
-                endpoint: 'create';
+                operation: 'create';
                 data: any;
                 params: {
                     pick?: string[];
@@ -17,34 +21,34 @@ declare module "@opra/common" {
                     include?: string[];
                 };
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }
         namespace Delete {
             interface Request extends _Request {
-                endpoint: 'delete';
+                operation: 'delete';
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }
         namespace Get {
             interface Request extends _Request {
-                endpoint: 'get';
+                operation: 'get';
                 params: {
                     pick?: string[];
                     omit?: string[];
                     include?: string[];
                 };
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }
         namespace Update {
             interface Request extends _Request {
-                endpoint: 'update';
+                operation: 'update';
                 data: any;
                 params: {
                     pick?: string[];
@@ -52,7 +56,7 @@ declare module "@opra/common" {
                     include?: string[];
                 };
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }

package/types/augmentation/storage.augmentation.d.ts

@@ -1,43 +1,43 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Readable } from 'stream';
-import type { EndpointContext } from '../adapter/endpoint-context';
-import type { MultipartIterator } from '../adapter/http/helpers/multipart-helper';
-import type { Request as _Request } from '../adapter/request.js';
+import type { MultipartIterator } from '../http/helpers/multipart-helper';
+import type { Request as _Request } from '../request.js';
+import type { RequestContext } from '../request-context.js';
 declare module "@opra/common" {
     namespace Storage {
         namespace Action {
+            interface Request extends _Request {
+                operation: 'action';
+                action: string;
+            }
             interface Context<TSession extends {} = {}> extends Resource.Context<TSession> {
             }
         }
         namespace Delete {
             interface Request extends _Request {
+                operation: 'delete';
+                path?: string;
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }
         namespace Get {
             interface Request extends _Request {
+                operation: 'get';
+                path?: string;
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }
         namespace Post {
             interface Request extends _Request {
+                operation: 'post';
+                path?: string;
                 parts: MultipartIterator;
             }
-            interface Context<TSession extends {} = {}> extends EndpointContext<TSession> {
+            interface Context<TSession extends {} = {}> extends RequestContext<TSession> {
                 request: Request;
             }
         }
     }
-    interface IStorage {
-        delete?(context: Storage.Delete.Context): Promise<number | undefined>;
-        get?(context: Storage.Get.Context): Promise<Buffer | Readable | undefined>;
-        post?(context: Storage.Post.Context): Promise<void>;
-        onInit?(): Promise<void>;
-        onShutdown?(): Promise<void>;
-    }
 }

package/types/{adapter/execution-context.d.ts → execution-context.d.ts}

@@ -1,6 +1,6 @@
-import type { HttpServerRequest } from './http/http-server-request';
-import type { HttpServerResponse } from './http/http-server-response';
-import type { Protocol } from './platform-adapter';
+import type { HttpServerRequest } from './http/http-server-request.js';
+import type { HttpServerResponse } from './http/http-server-response.js';
+import type { Protocol } from './platform-adapter.js';
 export interface ExecutionContext<TSession extends {} = {}> {
     readonly protocol: Protocol;
     readonly platform: string;

package/types/{adapter/execution-context.host.d.ts → execution-context.host.d.ts}

@@ -1,8 +1,8 @@
 import { AsyncEventEmitter } from 'strict-typed-events';
 import type { ApiDocument } from '@opra/common';
-import type { HttpServerResponse } from './/http/http-server-response.js';
 import type { ExecutionContext, HttpMessageContext, RpcMessageContext, WsMessageContext } from './execution-context.js';
 import type { HttpServerRequest } from './http/http-server-request.js';
+import type { HttpServerResponse } from './http/http-server-response.js';
 import { Protocol } from './platform-adapter.js';
 export declare class ExecutionContextHost<TSession extends {} = {}> extends AsyncEventEmitter implements ExecutionContext<TSession> {
     readonly api: ApiDocument;

package/types/{adapter/http → http/adapters}/express-adapter.d.ts

@@ -1,7 +1,7 @@
 import type { Application } from 'express';
 import type { ApiDocument } from '@opra/common';
-import type { PlatformAdapter } from '../platform-adapter.js';
-import type { HttpAdapter } from './http-adapter.js';
+import type { PlatformAdapter } from '../../platform-adapter';
+import type { NodeHttpAdapter } from './node-http-adapter';
 export interface ExpressAdapter extends PlatformAdapter {
     readonly app: Application;
 }
@@ -9,7 +9,7 @@ export interface ExpressAdapter extends PlatformAdapter {
  * @namespace
  */
 export declare namespace ExpressAdapter {
-    interface Options extends HttpAdapter.Options {
+    interface Options extends NodeHttpAdapter.Options {
     }
     function create(app: Application, api: ApiDocument, options?: ExpressAdapter.Options): Promise<ExpressAdapter>;
 }

package/types/http/adapters/express-adapter.host.d.ts

@@ -0,0 +1,12 @@
+import type { Application } from 'express';
+import { ApiDocument } from '@opra/common';
+import { HttpAdapterHost } from '../http-adapter-host.js';
+import type { ExpressAdapter } from './express-adapter.js';
+export declare class ExpressAdapterHost extends HttpAdapterHost implements ExpressAdapter {
+    protected _platform: string;
+    protected _app: Application;
+    constructor(app: Application);
+    get app(): Application;
+    protected init(api: ApiDocument, options?: ExpressAdapter.Options): Promise<void>;
+    static create(app: Application, api: ApiDocument, options?: ExpressAdapter.Options): Promise<ExpressAdapter>;
+}

package/types/{adapter/http/http-adapter.d.ts → http/adapters/node-http-adapter.d.ts}

@@ -1,17 +1,17 @@
 /// <reference types="node" />
 import http from 'http';
 import type { ApiDocument, OpraURLPath } from '@opra/common';
-import type { PlatformAdapter } from '../platform-adapter';
-export interface HttpAdapter extends PlatformAdapter {
+import type { PlatformAdapter } from '../../platform-adapter';
+export interface NodeHttpAdapter extends PlatformAdapter {
     readonly basePath: OpraURLPath;
     readonly server: http.Server;
 }
 /**
- * @namespace HttpAdapter
+ * @namespace NodeHttpAdapter
  */
-export declare namespace HttpAdapter {
+export declare namespace NodeHttpAdapter {
     type Options = PlatformAdapter.Options & {
         basePath?: string;
     };
-    function create(api: ApiDocument, options?: Options): Promise<HttpAdapter>;
+    function create(api: ApiDocument, options?: Options): Promise<NodeHttpAdapter>;
 }

package/types/http/adapters/node-http-adapter.host.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import http from 'http';
+import { ApiDocument, OpraURLPath } from '@opra/common';
+import { HttpAdapterHost } from '../http-adapter-host.js';
+import type { NodeHttpAdapter } from './node-http-adapter';
+/**
+ * @class NodeHttpAdapterHost
+ */
+export declare class NodeHttpAdapterHost extends HttpAdapterHost implements NodeHttpAdapter {
+    protected _platform: string;
+    protected _basePath: OpraURLPath;
+    protected _server: http.Server;
+    get basePath(): OpraURLPath;
+    get server(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    close(): Promise<void>;
+    protected init(api: ApiDocument, options?: NodeHttpAdapter.Options): Promise<void>;
+    protected _serverListener(incomingMessage: http.IncomingMessage, serverResponse: http.ServerResponse): void;
+    static create(api: ApiDocument, options?: NodeHttpAdapter.Options): Promise<NodeHttpAdapter>;
+}

package/types/http/helpers/json-body-loader.d.ts

@@ -0,0 +1,5 @@
+import bodyParser from 'body-parser';
+import type { HttpServerRequest } from '../http-server-request.js';
+type BodyLoaderFunction = (incoming: HttpServerRequest) => Promise<any>;
+export declare function jsonBodyLoader(options?: bodyParser.OptionsJson, cachePoint?: Object): BodyLoaderFunction;
+export {};