@opra/core 0.22.0 → 0.23.1

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageRequestHandler = void 0;
+const tslib_1 = require("tslib");
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const common_1 = require("@opra/common");
+const operation_context_js_1 = require("../../operation-context.js");
+const request_host_js_1 = require("../../request.host.js");
+const response_host_js_1 = require("../../response.host.js");
+const multipart_helper_js_1 = require("../helpers/multipart-helper.js");
+const request_handler_base_js_1 = require("./request-handler-base.js");
+/**
+ * @class StorageRequestHandler
+ */
+class StorageRequestHandler extends request_handler_base_js_1.RequestHandlerBase {
+    constructor(adapter, options) {
+        super(adapter);
+        this.adapter = adapter;
+        this._uploadDir = options?.uploadDir || os_1.default.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 response_host_js_1.ResponseHost({ http: outgoing });
+        const context = operation_context_js_1.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 common_1.Storage))
+                return;
+            switch (incoming.method) {
+                case 'GET': {
+                    const operationMeta = await this.assertOperation(resource, 'get');
+                    return new request_host_js_1.RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        resource,
+                        operation: 'get',
+                        contentId
+                    });
+                }
+                case 'DELETE': {
+                    const operationMeta = await this.assertOperation(resource, 'delete');
+                    return new request_host_js_1.RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        resource,
+                        operation: 'delete',
+                        contentId
+                    });
+                }
+                case 'POST': {
+                    const operationMeta = await this.assertOperation(resource, 'post');
+                    await promises_1.default.mkdir(this._uploadDir, { recursive: true });
+                    const multipartIterator = new multipart_helper_js_1.MultipartIterator(incoming, {
+                        ...operationMeta,
+                        filename: () => this.adapter.serviceName + '_p' + process.pid +
+                            't' + String(Date.now()).substring(8) + 'r' + (0, common_1.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 request_host_js_1.RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        resource,
+                        operation: 'post',
+                        contentId,
+                        parts: multipartIterator
+                    });
+                }
+            }
+        }
+        catch (e) {
+            if (e instanceof common_1.OpraException)
+                throw e;
+            throw new common_1.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 || common_1.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) || (0, common_1.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();
+    }
+}
+exports.StorageRequestHandler = StorageRequestHandler;

package/cjs/adapter/operation-context.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationContext = void 0;
+var OperationContext;
+(function (OperationContext) {
+    function from(executionContext, request, response) {
+        const out = {
+            request,
+            response,
+            requestScope: {}
+        };
+        Object.setPrototypeOf(out, executionContext);
+        return out;
+    }
+    OperationContext.from = from;
+})(OperationContext || (exports.OperationContext = OperationContext = {}));

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformAdapterHost = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+const strict_typed_events_1 = require("strict-typed-events");
+const common_1 = require("@opra/common");
+const logger_js_1 = require("./services/logger.js");
+/**
+ * @class PlatformAdapterHost
+ */
+class PlatformAdapterHost extends strict_typed_events_1.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_js_1.Logger
+            ? options.logger
+            : new logger_js_1.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 = (0, putil_varhelpers_1.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 common_1.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 || common_1.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 common_1.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 = common_1.I18n.createInstance(opts);
+        await instance.init();
+        await instance.loadResourceDir(path_1.default.resolve((0, common_1.getStackFileName)(), '../../../i18n'));
+        if (options?.resourceDirs)
+            for (const dir of options.resourceDirs)
+                await instance.loadResourceDir(dir);
+        return instance;
+    }
+}
+exports.PlatformAdapterHost = PlatformAdapterHost;

package/cjs/adapter/request.host.js

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestHost = void 0;
 class RequestHost {
     constructor(init) {
-        this.contentId = '';
         Object.assign(this, init);
-        this.resourceKind = this.resource.kind;
+        this.params = this.params || {};
     }
     switchToHttp() {
         if (this.http)

package/cjs/adapter/request.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/adapter/response.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/adapter/services/logger.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+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);
+    }
+}
+exports.Logger = Logger;

package/cjs/augmentation/collection.augmentation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/augmentation/singleton.augmentation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/augmentation/storage.augmentation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/index.js

@@ -3,16 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 require("reflect-metadata");
 require("./augmentation/resource.augmentation.js");
+require("./augmentation/collection.augmentation.js");
+require("./augmentation/singleton.augmentation.js");
+require("./augmentation/storage.augmentation.js");
 tslib_1.__exportStar(require("./types.js"), exports);
-tslib_1.__exportStar(require("./adapter/adapter.js"), exports);
+tslib_1.__exportStar(require("./adapter/execution-context.js"), exports);
+tslib_1.__exportStar(require("./adapter/operation-context.js"), exports);
+tslib_1.__exportStar(require("./adapter/platform-adapter.js"), exports);
+tslib_1.__exportStar(require("./adapter/request.js"), exports);
+tslib_1.__exportStar(require("./adapter/response.js"), exports);
 tslib_1.__exportStar(require("./adapter/http/express-adapter.js"), exports);
 tslib_1.__exportStar(require("./adapter/http/http-adapter.js"), exports);
-tslib_1.__exportStar(require("./adapter/http/impl/http-server-request.js"), exports);
-tslib_1.__exportStar(require("./adapter/http/impl/http-server-response.js"), exports);
-tslib_1.__exportStar(require("./adapter/http/impl/http-incoming-message-host.js"), exports);
-tslib_1.__exportStar(require("./adapter/http/impl/http-outgoing-message-host.js"), exports);
-tslib_1.__exportStar(require("./adapter/interfaces/request-context.interface.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/impl/http-incoming-message.host.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/impl/http-outgoing-message.host.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/http-server-request.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/http-server-response.js"), exports);
 tslib_1.__exportStar(require("./adapter/interfaces/logger.interface.js"), exports);
-tslib_1.__exportStar(require("./adapter/interfaces/request.interface.js"), exports);
-tslib_1.__exportStar(require("./adapter/interfaces/response.interface.js"), exports);
-tslib_1.__exportStar(require("./shared/collection-resource-base.js"), exports);
+tslib_1.__exportStar(require("./adapter/interfaces/request-handler.interface.js"), exports);
+tslib_1.__exportStar(require("./adapter/services/logger.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/helpers/multipart-helper.js"), exports);

package/esm/adapter/execution-context.host.js

@@ -0,0 +1,44 @@
+import { AsyncEventEmitter } from 'strict-typed-events';
+export class ExecutionContextHost extends AsyncEventEmitter {
+    constructor(api, platform, protocol) {
+        super();
+        this.api = api;
+        this.platform = platform;
+        this.errors = [];
+        this.executionScope = {};
+        this.ws = protocol.ws;
+        this.rpc = protocol.rpc;
+        if (protocol.http) {
+            this.protocol = 'http';
+            this.http = {
+                platform,
+                incoming: protocol.http.incoming,
+                outgoing: protocol.http.outgoing,
+                switchToContext: () => this
+            };
+        }
+        else if (protocol.ws) {
+            this.protocol = 'ws';
+            this.ws = protocol.ws;
+        }
+        else if (protocol.rpc) {
+            this.protocol = 'rpc';
+            this.rpc = protocol.rpc;
+        }
+    }
+    switchToHttp() {
+        if (this.http)
+            return this.http;
+        throw new TypeError('Not executing in an "Http" context');
+    }
+    switchToWs() {
+        if (this.ws)
+            return this.ws;
+        throw new TypeError('Not executing in an "WebSocket" context');
+    }
+    switchToRpc() {
+        if (this.rpc)
+            return this.rpc;
+        throw new TypeError('Not executing in an "RPC" context');
+    }
+}

package/esm/adapter/http/express-adapter.host.js

@@ -0,0 +1,20 @@
+import { OpraURLPath } from '@opra/common';
+import { HttpAdapterBase } from './http-adapter-base.js';
+import { HttpServerRequest } from './http-server-request.js';
+import { HttpServerResponse } from './http-server-response.js';
+export class ExpressAdapterHost extends HttpAdapterBase {
+    constructor(app, api, options) {
+        super(api, options);
+        this._platform = 'express';
+        const basePath = new OpraURLPath(options?.basePath);
+        app.use(basePath.toString(), (_req, _res) => {
+            const req = HttpServerRequest.from(_req);
+            const res = HttpServerResponse.from(_res);
+            this.handleIncoming(req, res)
+                .catch(() => void 0);
+        });
+    }
+    get app() {
+        return this._app;
+    }
+}

package/esm/adapter/http/express-adapter.js

@@ -1,22 +1,13 @@
-import { normalizePath } from '@opra/common';
-import { OpraHttpAdapter } from './http-adapter.js';
-import { HttpServerRequest } from './impl/http-server-request.js';
-import { HttpServerResponse } from './impl/http-server-response.js';
-export class OpraExpressAdapter extends OpraHttpAdapter {
-    constructor() {
-        super(...arguments);
-        this.platform = 'express';
-    }
-    static async create(app, document, options) {
-        const express = await import('express');
-        const adapter = new OpraExpressAdapter(document);
-        await adapter.init(options);
-        const prefix = '/' + normalizePath(options?.prefix, true);
-        app.use(prefix, express.json());
-        app.use(prefix, (req, res, next) => {
-            adapter.handler(HttpServerRequest.create(req), HttpServerResponse.create(res))
-                .catch(e => next(e));
-        });
+import { ExpressAdapterHost } from './express-adapter.host.js';
+/**
+ * @namespace
+ */
+export var ExpressAdapter;
+(function (ExpressAdapter) {
+    async function create(app, api, options) {
+        const adapter = new ExpressAdapterHost(app, api, options);
+        await adapter.init();
         return adapter;
     }
-}
+    ExpressAdapter.create = create;
+})(ExpressAdapter || (ExpressAdapter = {}));

package/esm/adapter/http/helpers/concat-readable.js

@@ -0,0 +1,16 @@
+import { PassThrough } from 'stream';
+export function concatReadable(...streams) {
+    const out = new PassThrough();
+    const pipeNext = () => {
+        const nextStream = streams.shift();
+        if (nextStream) {
+            nextStream.pipe(out, { end: false });
+            nextStream.once('end', () => pipeNext());
+        }
+        else {
+            out.end();
+        }
+    };
+    pipeNext();
+    return out;
+}

package/esm/adapter/http/helpers/multipart-helper.js

@@ -0,0 +1,91 @@
+import { EventEmitter } from 'events';
+import formidable from 'formidable';
+import fs from 'fs/promises';
+const noOp = () => void 0;
+export class MultipartIterator extends EventEmitter {
+    constructor(incoming, options) {
+        super();
+        this._cancelled = false;
+        this._items = [];
+        this._stack = [];
+        this.setMaxListeners(1000);
+        const form = this._form = formidable({
+            ...options,
+            filter: (part) => {
+                return !this._cancelled && (!options?.filter || options.filter(part));
+            }
+        });
+        form.once('error', () => {
+            this._cancelled = true;
+            if (this.listenerCount('error') > 0)
+                this.emit('error');
+        });
+        form.on('field', (field, value) => {
+            const item = { field, value };
+            this._items.push(item);
+            this._stack.push(item);
+            this.emit('item', item);
+        });
+        form.on('file', (field, file) => {
+            const item = { field, file };
+            this._items.push(item);
+            this._stack.push(item);
+            this.emit('item', item);
+        });
+        form.parse(incoming).catch(noOp);
+    }
+    get items() {
+        return this._items;
+    }
+    getNext() {
+        if (this._form.ended)
+            return Promise.resolve(undefined);
+        this.resume();
+        return new Promise((resolve, reject) => {
+            if (this._stack.length)
+                return resolve(this._stack.shift());
+            this.once('item', () => resolve(this._stack.shift()));
+            this.once('error', (e) => reject(e));
+        });
+    }
+    getAll() {
+        if (this._form.ended)
+            return Promise.resolve([...this._items]);
+        this.resume();
+        return new Promise((resolve, reject) => {
+            this._form.once('error', reject);
+            this._form.once('end', () => {
+                resolve([...this._items]);
+            });
+        });
+    }
+    cancel() {
+        this._cancelled = true;
+        this.resume();
+    }
+    resume() {
+        this._form.resume();
+    }
+    pause() {
+        this._form.pause();
+    }
+    async deleteFiles() {
+        const promises = [];
+        this._items
+            .forEach(item => {
+            if (!item.file)
+                return;
+            const file = item.file;
+            promises.push(new Promise(resolve => {
+                if (file._writeStream.closed)
+                    return resolve();
+                file._writeStream.once('close', resolve);
+            }).then(() => {
+                return fs.unlink(file.filepath);
+            }).then(() => {
+                return 0;
+            }));
+        });
+        return Promise.allSettled(promises);
+    }
+}

package/esm/adapter/http/helpers/query-parsers.js

@@ -0,0 +1,12 @@
+import { splitString } from 'fast-tokenizer';
+export function parseArrayParam(v) {
+    if (!v)
+        return;
+    return splitString(v, {
+        delimiters: ',',
+        quotes: true,
+        brackets: true,
+        keepBrackets: true,
+        keepQuotes: true
+    }).map(x => x.trim());
+}