@opra/core 0.21.0 → 0.23.0

package/esm/adapter/http/request-handlers/request-handler-base.js

@@ -0,0 +1,23 @@
+import { ForbiddenError, translate } from '@opra/common';
+/**
+ * @class RequestHandlerBase
+ */
+export class RequestHandlerBase {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    async assertOperation(resource, operation) {
+        const controller = await this.adapter.getController(resource);
+        const operationMeta = (typeof controller?.[operation] === 'function') && resource.operations[operation];
+        if (operationMeta)
+            return {
+                ...operationMeta,
+                controller
+            };
+        throw new ForbiddenError({
+            message: translate('RESOLVER_FORBIDDEN', { resource: resource.name, operation }, `'{{resource}}' endpoint does not accept '{{operation}}' operations`),
+            severity: 'error',
+            code: 'RESOLVER_FORBIDDEN'
+        });
+    }
+}

package/esm/adapter/http/request-handlers/storage-request-handler.js

@@ -0,0 +1,129 @@
+import fs from 'fs/promises';
+import os from 'os';
+import { BadRequestError, HttpStatusCodes, isReadable, OpraException, Storage, uid } from '@opra/common';
+import { OperationContext } from '../../operation-context.js';
+import { RequestHost } from '../../request.host.js';
+import { ResponseHost } from '../../response.host.js';
+import { MultipartIterator } from '../helpers/multipart-helper.js';
+import { RequestHandlerBase } from './request-handler-base.js';
+/**
+ * @class StorageRequestHandler
+ */
+export class StorageRequestHandler extends RequestHandlerBase {
+    constructor(adapter, options) {
+        super(adapter);
+        this.adapter = adapter;
+        this._uploadDir = options?.uploadDir || os.tmpdir();
+    }
+    async processRequest(executionContext) {
+        const { incoming, outgoing } = executionContext.switchToHttp();
+        // Parse incoming message and create Request object
+        const request = await this.parseRequest(executionContext, incoming);
+        if (!request)
+            return;
+        const response = new ResponseHost({ http: outgoing });
+        const context = OperationContext.from(executionContext, request, response);
+        // Execute operation
+        await this.executeOperation(context);
+        if (response.errors.length) {
+            context.errors.push(...response.errors);
+            return;
+        }
+        await this.sendResponse(context);
+    }
+    async parseRequest(executionContext, incoming) {
+        const contentId = incoming.headers['content-id'];
+        const p = incoming.parsedUrl.path[0];
+        const resource = this.adapter.api.getResource(p.resource);
+        try {
+            if (!(resource instanceof Storage))
+                return;
+            switch (incoming.method) {
+                case 'GET': {
+                    const operationMeta = await this.assertOperation(resource, 'get');
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        resource,
+                        operation: 'get',
+                        contentId
+                    });
+                }
+                case 'DELETE': {
+                    const operationMeta = await this.assertOperation(resource, 'delete');
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        resource,
+                        operation: 'delete',
+                        contentId
+                    });
+                }
+                case 'POST': {
+                    const operationMeta = await this.assertOperation(resource, 'post');
+                    await fs.mkdir(this._uploadDir, { recursive: true });
+                    const multipartIterator = new MultipartIterator(incoming, {
+                        ...operationMeta,
+                        filename: () => this.adapter.serviceName + '_p' + process.pid +
+                            't' + String(Date.now()).substring(8) + 'r' + uid(12)
+                    });
+                    multipartIterator.pause();
+                    // Add an hook to clean up files after request finished
+                    executionContext.on('finish', async () => {
+                        multipartIterator.cancel();
+                        await multipartIterator.deleteFiles().catch(() => void 0);
+                    });
+                    return new RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        resource,
+                        operation: 'post',
+                        contentId,
+                        parts: multipartIterator
+                    });
+                }
+            }
+        }
+        catch (e) {
+            if (e instanceof OpraException)
+                throw e;
+            throw new BadRequestError(e);
+        }
+    }
+    async executeOperation(context) {
+        const request = context.request;
+        const { response } = context;
+        // Call operation handler method
+        let value;
+        try {
+            value = await request.controller[request.operation].call(request.controller, context);
+            if (response.value == null)
+                response.value = value;
+        }
+        catch (error) {
+            response.errors.push(error);
+        }
+    }
+    async sendResponse(context) {
+        const { response } = context;
+        const outgoing = response.switchToHttp();
+        outgoing.statusCode = outgoing.statusCode || HttpStatusCodes.OK;
+        if (response.value != null) {
+            if (typeof response.value === 'string') {
+                if (!outgoing.hasHeader('content-type'))
+                    outgoing.setHeader('content-type', 'text/plain');
+                outgoing.send(response.value);
+            }
+            else if (Buffer.isBuffer(response.value) || isReadable(response.value)) {
+                if (!outgoing.hasHeader('content-type'))
+                    outgoing.setHeader('content-type', 'application/octet-stream');
+                outgoing.send(response.value);
+            }
+            else {
+                outgoing.setHeader('content-type', 'application/json; charset=utf-8');
+                outgoing.send(JSON.stringify(response.value));
+            }
+        }
+        outgoing.end();
+    }
+}

package/esm/adapter/operation-context.js

@@ -0,0 +1,13 @@
+export var OperationContext;
+(function (OperationContext) {
+    function from(executionContext, request, response) {
+        const out = {
+            request,
+            response,
+            requestScope: {}
+        };
+        Object.setPrototypeOf(out, executionContext);
+        return out;
+    }
+    OperationContext.from = from;
+})(OperationContext || (OperationContext = {}));

package/esm/adapter/platform-adapter.host.js

@@ -0,0 +1,102 @@
+import path from 'path';
+import { pascalCase } from 'putil-varhelpers';
+import { AsyncEventEmitter } from 'strict-typed-events';
+import { getStackFileName, I18n, Resource } from '@opra/common';
+import { Logger } from './services/logger.js';
+/**
+ * @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._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;
+    }
+    get platform() {
+        return this._platform;
+    }
+    get protocol() {
+        return this._protocol;
+    }
+    get serviceName() {
+        return this.api.info.title;
+    }
+    async close() {
+        const promises = [];
+        for (const r of this.api.resources.values()) {
+            const onShutdown = r.onShutdown;
+            if (onShutdown)
+                promises.push((async () => onShutdown.call(r.controller, r))());
+        }
+        await Promise.allSettled(promises);
+    }
+    /**
+     * Initializes the adapter
+     */
+    async init() {
+        if (this._initialized)
+            return;
+        // 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();
+        else
+            this._i18n = await this._createI18n(this._options?.i18n);
+        this._i18n = this._i18n || I18n.defaultInstance;
+        if (!this._i18n.isInitialized)
+            await this._i18n.init();
+        // Initialize all controllers
+        for (const resource of this.api.resources.values()) {
+            await this.getController(resource);
+        }
+        this._initialized = true;
+    }
+    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);
+            }
+        }
+        return controller;
+    }
+    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/request.host.js

@@ -1,8 +1,7 @@
 export class RequestHost {
     constructor(init) {
-        this.contentId = '';
         Object.assign(this, init);
-        this.resourceKind = this.resource.kind;
+        this.params = this.params || {};
     }
     switchToHttp() {
         if (this.http)

package/esm/adapter/request.js

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

package/esm/adapter/response.js

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

package/esm/adapter/services/logger.js

@@ -0,0 +1,32 @@
+export class Logger {
+    constructor(options = {}) {
+        this._instance = options.instance ||
+            (!(process.env.NODE_ENV || '').includes('test') ? globalThis.console : {});
+    }
+    info(message, ...optionalParams) {
+        (this._instance.info || this._instance.log)?.(message, ...optionalParams);
+    }
+    error(message, ...optionalParams) {
+        if (this._instance.error) {
+            this._instance.error(message, ...optionalParams);
+            return;
+        }
+        this.info(message, ...optionalParams);
+    }
+    fatal(message, ...optionalParams) {
+        if (this._instance.fatal) {
+            this._instance.fatal(message, ...optionalParams);
+            return;
+        }
+        this.error(message, ...optionalParams);
+    }
+    warn(message, ...optionalParams) {
+        this._instance.warn?.(message, ...optionalParams);
+    }
+    debug(message, ...optionalParams) {
+        this._instance.debug?.(message, ...optionalParams);
+    }
+    verbose(message, ...optionalParams) {
+        this._instance.verbose?.(message, ...optionalParams);
+    }
+}

package/esm/augmentation/collection.augmentation.js

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

package/esm/augmentation/singleton.augmentation.js

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

package/esm/augmentation/storage.augmentation.js

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

package/esm/index.js

@@ -1,15 +1,21 @@
 import "reflect-metadata";
 import './augmentation/resource.augmentation.js';
+import './augmentation/collection.augmentation.js';
+import './augmentation/singleton.augmentation.js';
+import './augmentation/storage.augmentation.js';
 export * from './types.js';
-export * from './adapter/adapter.js';
+export * from './adapter/execution-context.js';
+export * from './adapter/operation-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-server-request.js';
-export * from './adapter/http/impl/http-server-response.js';
-export * from './adapter/http/impl/http-incoming-message-host.js';
-export * from './adapter/http/impl/http-outgoing-message-host.js';
-export * from './adapter/interfaces/request-context.interface.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/interfaces/logger.interface.js';
-export * from './adapter/interfaces/request.interface.js';
-export * from './adapter/interfaces/response.interface.js';
-export * from './shared/collection-resource-base.js';
+export * from './adapter/interfaces/request-handler.interface.js';
+export * from './adapter/services/logger.js';
+export * from './adapter/http/helpers/multipart-helper.js';

package/i18n/en/error.json

@@ -10,6 +10,9 @@
   "UNPROCESSABLE_ENTITY": "Unprocessable entity",
   "RESOURCE_NOT_FOUND": "Resource not found: '{{resource}}'",
   "RESOURCE_CONFLICT": "There is already an other {{resource}} resource with same field values ({{fields}})",
-  "RESOLVER_FORBIDDEN": "The resource endpoint does not accept '{{operation}}' operations",
-  "UNACCEPTED_SORT_FIELD": "Field '{{field}}' is not available for sort operation"
+  "RESOLVER_FORBIDDEN": "The {{resource}} endpoint does not accept '{{operation}}' 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",
+  "UNACCEPTED_FILTER_OPERATION": "'{{operation}}' for field '{{field}}' is not available for filter operation"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -27,18 +27,19 @@
     "clean:cover": "rimraf ../../coverage/core"
   },
   "dependencies": {
-    "@opra/common": "^0.21.0",
+    "@opra/common": "^0.23.0",
     "accepts": "^1.3.8",
-    "cookie": "^0.5.0",
-    "cookie-signature": "^1.2.1",
     "content-disposition": "^0.5.4",
     "content-type": "^1.0.5",
+    "cookie": "^0.5.0",
+    "cookie-signature": "^1.2.1",
     "encodeurl": "^1.0.2",
-    "fresh": "^0.5.2",
     "formidable": "^3.5.0",
+    "fresh": "^0.5.2",
     "mime-types": "^2.1.35",
     "power-tasks": "^1.7.0",
     "putil-varhelpers": "^1.6.5",
+    "putil-isplainobject": "^1.1.5",
     "range-parser": "^1.2.1",
     "strict-typed-events": "^2.3.1",
     "type-is": "^1.6.18",
@@ -55,9 +56,9 @@
     "@types/cookie": "^0.5.1",
     "@types/cookie-signature": "^1.1.0",
     "@types/encodeurl": "^1.0.0",
-    "@types/fresh": "^0.5.0",
-    "@types/formidable": "^3.4.0",
     "@types/express": "^4.17.17",
+    "@types/formidable": "^3.4.0",
+    "@types/fresh": "^0.5.0",
     "@types/mime-types": "^2.1.1",
     "@types/range-parser": "^1.2.4",
     "@types/type-is": "^1.6.3",

package/types/adapter/execution-context.d.ts

@@ -0,0 +1,31 @@
+import type { HttpServerRequest } from './http/http-server-request';
+import type { HttpServerResponse } from './http/http-server-response';
+import type { Protocol } from './platform-adapter';
+export declare namespace ExecutionContext {
+    type OnFinishArgs = {
+        context: ExecutionContext;
+        failed: boolean;
+    };
+}
+export interface ExecutionContext {
+    readonly protocol: Protocol;
+    readonly platform: string;
+    errors: Error[];
+    executionScope: Record<string | number | symbol, any>;
+    switchToHttp(): HttpMessageContext;
+    switchToWs(): WsMessageContext;
+    switchToRpc(): RpcMessageContext;
+    on(event: 'finish', fn: (args: ExecutionContext.OnFinishArgs) => void | Promise<void>): any;
+}
+export interface HttpMessageContext {
+    readonly platform: string;
+    readonly incoming: HttpServerRequest;
+    readonly outgoing: HttpServerResponse;
+    switchToContext(): ExecutionContext;
+}
+export interface WsMessageContext {
+    switchToContext(): ExecutionContext;
+}
+export interface RpcMessageContext {
+    switchToContext(): ExecutionContext;
+}

package/types/adapter/execution-context.host.d.ts

@@ -0,0 +1,27 @@
+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 { Protocol } from './platform-adapter.js';
+export declare class ExecutionContextHost extends AsyncEventEmitter implements ExecutionContext {
+    readonly api: ApiDocument;
+    readonly platform: string;
+    readonly protocol: Protocol;
+    readonly http?: HttpMessageContext;
+    readonly ws?: WsMessageContext;
+    readonly rpc?: RpcMessageContext;
+    errors: Error[];
+    executionScope: Record<string | number | symbol, any>;
+    constructor(api: ApiDocument, platform: string, protocol: {
+        http?: {
+            incoming: HttpServerRequest;
+            outgoing: HttpServerResponse;
+        };
+        ws?: WsMessageContext;
+        rpc?: RpcMessageContext;
+    });
+    switchToHttp(): HttpMessageContext;
+    switchToWs(): WsMessageContext;
+    switchToRpc(): RpcMessageContext;
+}

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

@@ -1,11 +1,15 @@
 import type { Application } from 'express';
-import { ApiDocument } from '@opra/common';
-import { OpraHttpAdapter } from './http-adapter.js';
-export declare namespace OpraExpressAdapter {
-    interface Options extends OpraHttpAdapter.Options {
-    }
+import type { ApiDocument } from '@opra/common';
+import type { PlatformAdapter } from '../platform-adapter.js';
+import type { HttpAdapter } from './http-adapter.js';
+export interface ExpressAdapter extends PlatformAdapter {
+    readonly app: Application;
 }
-export declare class OpraExpressAdapter extends OpraHttpAdapter {
-    protected platform: string;
-    static create(app: Application, document: ApiDocument, options?: OpraExpressAdapter.Options): Promise<OpraExpressAdapter>;
+/**
+ * @namespace
+ */
+export declare namespace ExpressAdapter {
+    interface Options extends HttpAdapter.Options {
+    }
+    function create(app: Application, api: ApiDocument, options?: ExpressAdapter.Options): Promise<ExpressAdapter>;
 }

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

@@ -0,0 +1,11 @@
+import type { Application } from 'express';
+import { ApiDocument } from '@opra/common';
+import type { ExpressAdapter } from './express-adapter';
+import { HttpAdapterBase } from './http-adapter-base.js';
+export declare class ExpressAdapterHost extends HttpAdapterBase implements ExpressAdapter {
+    _platform: string;
+    _options: ExpressAdapter.Options;
+    _app: Application;
+    constructor(app: Application, api: ApiDocument, options?: ExpressAdapter.Options);
+    get app(): Application;
+}

package/types/adapter/http/helpers/concat-readable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+export declare function concatReadable(...streams: Readable[]): Readable;

package/types/adapter/http/helpers/multipart-helper.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import formidable from 'formidable';
+import type IncomingForm from 'formidable/Formidable.js';
+import { HttpIncomingMessage } from '../impl/http-incoming-message.host.js';
+export type MultipartFile = formidable.File;
+export type MultipartItem = {
+    field: string;
+    value?: string;
+    file?: MultipartFile;
+};
+export declare class MultipartIterator extends EventEmitter {
+    protected _cancelled: boolean;
+    protected _form: IncomingForm;
+    protected _items: MultipartItem[];
+    protected _stack: MultipartItem[];
+    constructor(incoming: HttpIncomingMessage, options?: formidable.Options);
+    get items(): MultipartItem[];
+    getNext(): Promise<MultipartItem | undefined>;
+    getAll(): Promise<MultipartItem[]>;
+    cancel(): void;
+    resume(): void;
+    pause(): void;
+    deleteFiles(): Promise<PromiseSettledResult<any>[]>;
+}

package/types/adapter/http/helpers/query-parsers.d.ts

@@ -0,0 +1 @@
+export declare function parseArrayParam(v?: string | null): string[] | undefined;

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

@@ -0,0 +1,23 @@
+import { ExecutionContext } from '../execution-context.js';
+import { RequestHandler } from '../interfaces/request-handler.interface.js';
+import type { Protocol } from '../platform-adapter';
+import { PlatformAdapterHost } from '../platform-adapter.host.js';
+import { HttpServerRequest } from './http-server-request.js';
+import { HttpServerResponse } from './http-server-response.js';
+/**
+ *
+ * @class HttpAdapterBase
+ */
+export declare abstract class HttpAdapterBase extends PlatformAdapterHost {
+    _protocol: Protocol;
+    _requestHandlers: RequestHandler[];
+    /**
+     * Main http request handler
+     * @param incoming
+     * @param outgoing
+     * @protected
+     */
+    protected handleIncoming(incoming: HttpServerRequest, outgoing: HttpServerResponse): Promise<void>;
+    processRequest(context: ExecutionContext): Promise<void>;
+    protected handleError(context: ExecutionContext): Promise<void>;
+}

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

@@ -1,33 +1,17 @@
-import { Task } from 'power-tasks';
-import { OpraAdapter } from '../adapter.js';
-import { ILogger } from '../interfaces/logger.interface.js';
-import { Request } from '../interfaces/request.interface.js';
-import { RequestContext } from '../interfaces/request-context.interface.js';
-import { HttpServerRequest } from './impl/http-server-request.js';
-import { HttpServerResponse } from './impl/http-server-response.js';
-/**
- * @namespace OpraHttpAdapter
- */
-export declare namespace OpraHttpAdapter {
-    type Options = OpraAdapter.Options & {
-        prefix?: string;
-    };
+/// <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 {
+    readonly basePath: OpraURLPath;
+    readonly server: http.Server;
 }
 /**
- *
- * @class OpraHttpAdapter
+ * @namespace HttpAdapter
  */
-export declare abstract class OpraHttpAdapter extends OpraAdapter {
-    protected abstract platform: string;
-    /**
-     * Main http request handler
-     * @param incoming
-     * @param outgoing
-     * @protected
-     */
-    protected handler(incoming: HttpServerRequest, outgoing: HttpServerResponse): Promise<void>;
-    protected createRequestTask(request: Request, outgoing: HttpServerResponse): Task;
-    protected executeRequest(context: RequestContext): Promise<void>;
-    protected handleError(incoming: HttpServerRequest, outgoing: HttpServerResponse, errors: any[]): Promise<void>;
-    protected log(logType: keyof ILogger, incoming: HttpServerRequest, message: string, ...optionalParams: any[]): void;
+export declare namespace HttpAdapter {
+    type Options = PlatformAdapter.Options & {
+        basePath?: string;
+    };
+    function create(api: ApiDocument, options?: Options): Promise<HttpAdapter>;
 }

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import http from 'http';
+import { ApiDocument, OpraURLPath } from '@opra/common';
+import type { HttpAdapter } from './http-adapter';
+import { HttpAdapterBase } from './http-adapter-base.js';
+/**
+ * @class HttpAdapterHost
+ */
+export declare class HttpAdapterHost extends HttpAdapterBase implements HttpAdapter {
+    _basePath: OpraURLPath;
+    _options: HttpAdapter.Options;
+    _server: http.Server;
+    constructor(api: ApiDocument, options?: HttpAdapter.Options);
+    get basePath(): OpraURLPath;
+    get server(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    protected _serverListener(incomingMessage: http.IncomingMessage, serverResponse: http.ServerResponse): void;
+    close(): Promise<void>;
+}