@opra/core 0.25.5 → 0.26.0

package/esm/index.js

@@ -1,16 +1,17 @@
 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 './execution-context.js';
-export * from './endpoint-context.js';
+export * from './request-context.js';
 export * from './platform-adapter.js';
 export * from './request.js';
 export * from './response.js';
-export * from './http/express-adapter.js';
-export * from './http/http-adapter.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';

package/esm/platform-adapter.host.js

@@ -1,34 +1,19 @@
 import path from 'path';
 import { pascalCase } from 'putil-varhelpers';
 import { AsyncEventEmitter } from 'strict-typed-events';
-import { getStackFileName, I18n, Resource } from '@opra/common';
+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(api, options) {
-        super();
-        this.api = api;
-        this._controllers = new WeakMap();
-        this._initialized = false;
-        this._options = options || {};
-        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;
+    constructor() {
+        super(...arguments);
+        this._controllers = new Map();
+    }
+    get api() {
+        return this._api;
     }
     get platform() {
         return this._platform;
@@ -37,56 +22,100 @@ export class PlatformAdapterHost extends AsyncEventEmitter {
         return this._protocol;
     }
     get serviceName() {
-        return this.api.info.title;
+        return this._serviceName;
+    }
+    get i18n() {
+        return this._i18n;
     }
     async close() {
         const promises = [];
-        for (const r of this.api.resources.values()) {
-            const onShutdown = r.onShutdown;
+        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() {
-        if (this._initialized)
-            return;
+    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 (this._options?.i18n instanceof I18n)
-            this._i18n = this._options.i18n;
-        else if (typeof this._options?.i18n === 'function')
-            this._i18n = await this._options.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(this._options?.i18n);
+            this._i18n = await this._createI18n(options?.i18n);
         this._i18n = this._i18n || I18n.defaultInstance;
         if (!this._i18n.isInitialized)
             await this._i18n.init();
         // Initialize all resources
-        for (const resource of this.api.resources.values()) {
-            await this.getController(resource);
-        }
-        this._initialized = true;
+        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) {
-            if (resource.controller) {
-                controller = typeof resource.controller === 'function' ?
-                    new resource.controller()
-                    : resource.controller;
-                // Initialize controller
-                if (typeof controller.onInit === 'function')
-                    await controller.onInit.call(controller);
-                this._controllers.set(resource, 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,

package/esm/{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/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/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.5",
+  "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.5",
+    "@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,16 +1,19 @@
 import type { PartialOutput } from '@opra/common';
-import type { EndpointContext } from '../endpoint-context.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[];
@@ -19,34 +22,34 @@ declare module "@opra/common" {
                     [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[];
@@ -60,13 +63,13 @@ declare module "@opra/common" {
                     [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[];
@@ -75,13 +78,13 @@ declare module "@opra/common" {
                     [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: {
@@ -91,20 +94,20 @@ declare module "@opra/common" {
                     [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 '../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 '../endpoint-context.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,46 +1,43 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Readable } from 'stream';
-import type { EndpointContext } from '../endpoint-context.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/http/{express-adapter.d.ts → 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/http/{http-adapter.d.ts → 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.js';
-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 {};

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

@@ -0,0 +1,34 @@
+import { Collection, OpraURLPath, OpraURLPathComponent, Parameter, Resource, Singleton, Storage } from '@opra/common';
+import { ExecutionContext } from '../execution-context.js';
+import { PlatformAdapterHost } from '../platform-adapter.host.js';
+import type { Protocol } from '../platform-adapter.js';
+import { RequestHost } from '../request.host.js';
+import { Request } from '../request.js';
+import { RequestContext } from '../request-context.js';
+import { HttpServerRequest } from './http-server-request.js';
+import { HttpServerResponse } from './http-server-response.js';
+/**
+ *
+ * @class HttpAdapterHost
+ */
+export declare abstract class HttpAdapterHost extends PlatformAdapterHost {
+    protected _protocol: Protocol;
+    protected _tempDir: string;
+    /**
+     * Main http request handler
+     * @param incoming
+     * @param outgoing
+     * @protected
+     */
+    protected handleHttp(incoming: HttpServerRequest, outgoing: HttpServerResponse): Promise<void>;
+    handleExecution(executionContext: ExecutionContext): Promise<void>;
+    parseRequest(executionContext: ExecutionContext): Promise<Request>;
+    protected _parseRequestAction(executionContext: ExecutionContext, resource: Resource, urlPath: OpraURLPath, searchParams: URLSearchParams): Promise<RequestHost>;
+    protected _parseRequestCollection(executionContext: ExecutionContext, resource: Collection, urlPath: OpraURLPath, searchParams: URLSearchParams): Promise<RequestHost>;
+    protected _parseRequestSingleton(executionContext: ExecutionContext, resource: Singleton, urlPath: OpraURLPath, searchParams?: URLSearchParams): Promise<RequestHost>;
+    protected _parseRequestStorage(executionContext: ExecutionContext, resource: Storage, urlPath: OpraURLPath, searchParams: URLSearchParams): Promise<RequestHost>;
+    protected parseParameters(paramDefs: Map<string, Parameter>, pathComponent: OpraURLPathComponent, searchParams?: URLSearchParams): Record<string, any>;
+    protected executeRequest(context: RequestContext): Promise<void>;
+    sendResponse(context: RequestContext): Promise<void>;
+    protected handleError(context: ExecutionContext): Promise<void>;
+}