@opra/core 0.25.5 → 0.26.0

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

@@ -1,139 +0,0 @@
-"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 endpoint_context_js_1 = require("../../endpoint-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 = endpoint_context_js_1.EndpointContext.from(executionContext, request, response);
-        await this.callEndpoint(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 endpointMeta = await this.assertEndpoint(resource, 'get');
-                    return new request_host_js_1.RequestHost({
-                        controller: endpointMeta.controller,
-                        http: incoming,
-                        resource,
-                        endpoint: 'get',
-                        contentId,
-                        path: incoming.parsedUrl.path.slice(1).toString().substring(1),
-                        params: this.parseParameters(incoming.parsedUrl, endpointMeta)
-                    });
-                }
-                case 'DELETE': {
-                    const endpointMeta = await this.assertEndpoint(resource, 'delete');
-                    return new request_host_js_1.RequestHost({
-                        controller: endpointMeta.controller,
-                        http: incoming,
-                        resource,
-                        endpoint: 'delete',
-                        contentId,
-                        path: incoming.parsedUrl.path.slice(1).toString().substring(1),
-                        params: this.parseParameters(incoming.parsedUrl, endpointMeta)
-                    });
-                }
-                case 'POST': {
-                    const endpointMeta = await this.assertEndpoint(resource, 'post');
-                    await promises_1.default.mkdir(this._uploadDir, { recursive: true });
-                    const multipartIterator = new multipart_helper_js_1.MultipartIterator(incoming, {
-                        ...endpointMeta,
-                        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: endpointMeta.controller,
-                        http: incoming,
-                        resource,
-                        endpoint: 'post',
-                        contentId,
-                        parts: multipartIterator,
-                        path: incoming.parsedUrl.path.slice(1).toString().substring(1),
-                        params: this.parseParameters(incoming.parsedUrl, endpointMeta)
-                    });
-                }
-            }
-        }
-        catch (e) {
-            if (e instanceof common_1.OpraException)
-                throw e;
-            throw new common_1.BadRequestError(e);
-        }
-    }
-    async callEndpoint(context) {
-        const request = context.request;
-        const { response } = context;
-        // Call endpoint handler method
-        let value;
-        try {
-            value = await request.controller[request.endpoint].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/esm/http/express-adapter.host.js

@@ -1,20 +0,0 @@
-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/http/http-adapter-base.js

@@ -1,134 +0,0 @@
-import { BadRequestError, HttpHeaderCodes, HttpStatusCodes, InternalServerError, IssueSeverity, OpraException, OpraSchema, wrapException } from '@opra/common';
-import { ExecutionContextHost } from '../execution-context.host.js';
-import { PlatformAdapterHost } from '../platform-adapter.host.js';
-import { EntityRequestHandler } from './request-handlers/entity-request-handler.js';
-import { StorageRequestHandler } from './request-handlers/storage-request-handler.js';
-/**
- *
- * @class HttpAdapterBase
- */
-export class HttpAdapterBase extends PlatformAdapterHost {
-    constructor() {
-        super(...arguments);
-        this._protocol = 'http';
-        this._requestHandlers = [
-            new EntityRequestHandler(this),
-            new StorageRequestHandler(this)
-        ];
-    }
-    /**
-     * Main http request handler
-     * @param incoming
-     * @param outgoing
-     * @protected
-     */
-    async handleIncoming(incoming, outgoing) {
-        const context = new ExecutionContextHost(this.api, this.platform, { http: { incoming, outgoing } });
-        try {
-            /* istanbul ignore next */
-            if (!this._initialized)
-                throw new InternalServerError(`${Object.getPrototypeOf(this).constructor.name} has not been initialized yet`);
-            outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
-            // Expose headers if cors enabled
-            if (outgoing.getHeader(HttpHeaderCodes.Access_Control_Allow_Origin)) {
-                // Expose X-Opra-* headers
-                outgoing.appendHeader(HttpHeaderCodes.Access_Control_Expose_Headers, Object.values(HttpHeaderCodes)
-                    .filter(k => k.toLowerCase().startsWith('x-opra-')));
-            }
-            let i = 0;
-            let requestProcessed = false;
-            const next = async () => {
-                while (i < this._interceptors.length) {
-                    const interceptor = this._interceptors[i++];
-                    if (interceptor)
-                        await interceptor(context, next);
-                }
-                if (!requestProcessed) {
-                    requestProcessed = true;
-                    await this.processRequest(context);
-                }
-            };
-            await next();
-        }
-        catch (error) {
-            context.errors.push(wrapException(error));
-        }
-        // If no response returned to the client we send an error
-        if (!outgoing.writableEnded) {
-            if (!context.errors.length)
-                context.errors.push(new BadRequestError(`Server can not process this request`));
-            await this.handleError(context);
-        }
-    }
-    async processRequest(context) {
-        try {
-            const { incoming, outgoing } = context.switchToHttp();
-            if (incoming.method === 'GET' && !incoming.parsedUrl.path.length) {
-                outgoing.setHeader('content-type', 'application/json');
-                outgoing.end(JSON.stringify(this.api.exportSchema({ webSafe: true })));
-                return;
-            }
-            const { parsedUrl } = incoming;
-            if (!parsedUrl.path.length) {
-                // Batch
-                if (incoming.headers['content-type'] === 'multipart/mixed') {
-                    // todo
-                }
-                throw new BadRequestError();
-            }
-            // Iterate through request handlers until one of them sends response (end outgoing stream)
-            for (const requestHandler of this._requestHandlers) {
-                await requestHandler.processRequest(context);
-                if (outgoing.writableEnded)
-                    return;
-                if (context.errors.length) {
-                    await this.handleError(context);
-                    return;
-                }
-            }
-        }
-        finally {
-            await context.emitAsync('finish');
-        }
-    }
-    async handleError(context) {
-        const { errors } = context;
-        const { outgoing } = context.switchToHttp();
-        if (outgoing.headersSent) {
-            outgoing.end();
-            return;
-        }
-        errors.forEach(x => {
-            // todo. implement a better log mechanism
-            if (x instanceof OpraException)
-                this._logger.fatal(x);
-            else
-                this._logger.error(x);
-        });
-        const wrappedErrors = errors.map(wrapException);
-        // Sort errors from fatal to info
-        wrappedErrors.sort((a, b) => {
-            const i = IssueSeverity.Keys.indexOf(a.severity) - IssueSeverity.Keys.indexOf(b.severity);
-            if (i === 0)
-                return b.status - a.status;
-            return i;
-        });
-        let status = outgoing.statusCode || 0;
-        if (!status || status < Number(HttpStatusCodes.BAD_REQUEST)) {
-            status = wrappedErrors[0].status;
-            if (status < Number(HttpStatusCodes.BAD_REQUEST))
-                status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
-        }
-        outgoing.statusCode = status;
-        const body = {
-            errors: wrappedErrors.map(x => this._i18n.deep(x.toJSON()))
-        };
-        outgoing.setHeader(HttpHeaderCodes.Content_Type, 'application/opra+json; charset=utf-8');
-        outgoing.setHeader(HttpHeaderCodes.Cache_Control, 'no-cache');
-        outgoing.setHeader(HttpHeaderCodes.Pragma, 'no-cache');
-        outgoing.setHeader(HttpHeaderCodes.Expires, '-1');
-        outgoing.setHeader(HttpHeaderCodes.X_Opra_Version, OpraSchema.SpecVersion);
-        outgoing.send(JSON.stringify(body));
-        outgoing.end();
-    }
-}

package/esm/http/http-adapter.js

@@ -1,13 +0,0 @@
-import { HttpAdapterHost } from './http-adapter.host.js';
-/**
- * @namespace HttpAdapter
- */
-export var HttpAdapter;
-(function (HttpAdapter) {
-    async function create(api, options) {
-        const adapter = new HttpAdapterHost(api, options);
-        await adapter.init();
-        return adapter;
-    }
-    HttpAdapter.create = create;
-})(HttpAdapter || (HttpAdapter = {}));