@opra/http 1.0.0-beta.3

package/cjs/utils/concat-readable.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concatReadable = concatReadable;
+const stream_1 = require("stream");
+function concatReadable(...streams) {
+    const out = new stream_1.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/cjs/utils/convert-to-headers.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToHeaders = convertToHeaders;
+exports.convertToHeadersDistinct = convertToHeadersDistinct;
+const match_known_fields_js_1 = require("./match-known-fields.js");
+function convertToHeaders(src, dst, joinDuplicateHeaders) {
+    for (let n = 0; n < src.length; n += 2) {
+        addHeaderLine(src[n], src[n + 1], dst, joinDuplicateHeaders);
+    }
+    return dst;
+}
+function convertToHeadersDistinct(src, dst) {
+    const count = src.length % 2;
+    for (let n = 0; n < count; n += 2) {
+        addHeaderLineDistinct(src[n], src[n + 1], dst);
+    }
+    return dst;
+}
+function addHeaderLine(field, value, dest, joinDuplicateHeaders) {
+    if (value == null)
+        return;
+    field = field.toLowerCase();
+    const [, flag] = (0, match_known_fields_js_1.matchKnownFields)(field);
+    // comma(0) or semicolon(2) delimited field
+    if (flag === match_known_fields_js_1.COMMA_DELIMITED_FIELD || flag === match_known_fields_js_1.SEMICOLON_DELIMITED_FIELD) {
+        // Make a delimited list
+        if (typeof dest[field] === 'string') {
+            dest[field] += (flag === match_known_fields_js_1.COMMA_DELIMITED_FIELD ? ', ' : '; ') + value;
+        }
+        else {
+            dest[field] = value;
+        }
+    }
+    else if (flag === match_known_fields_js_1.ARRAY_FIELD) {
+        // Array header -- only Set-Cookie at the moment
+        if (dest['set-cookie'] !== undefined) {
+            dest['set-cookie'].push(value);
+        }
+        else {
+            dest['set-cookie'] = [value];
+        }
+    }
+    else if (joinDuplicateHeaders) {
+        if (dest[field] === undefined) {
+            dest[field] = value;
+        }
+        else {
+            dest[field] += ', ' + value;
+        }
+    }
+    else if (dest[field] === undefined) {
+        // Drop duplicates
+        dest[field] = value;
+    }
+}
+function addHeaderLineDistinct(field, value, dest) {
+    field = field.toLowerCase();
+    if (!dest[field]) {
+        dest[field] = [value];
+    }
+    else {
+        dest[field].push(value);
+    }
+}

package/cjs/utils/convert-to-raw-headers.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToRawHeaders = convertToRawHeaders;
+const match_known_fields_js_1 = require("./match-known-fields.js");
+function convertToRawHeaders(src) {
+    return Object.entries(src).reduce((a, [field, v]) => {
+        const [name, flag] = (0, match_known_fields_js_1.matchKnownFields)(field);
+        if (flag === match_known_fields_js_1.ARRAY_FIELD) {
+            if (Array.isArray(v))
+                v.forEach(x => a.push(name, String(x)));
+            else
+                a.push(name, String(v));
+            return a;
+        }
+        if (flag === match_known_fields_js_1.COMMA_DELIMITED_FIELD || flag === match_known_fields_js_1.SEMICOLON_DELIMITED_FIELD) {
+            v = Array.isArray(v) ? v.join(flag === match_known_fields_js_1.COMMA_DELIMITED_FIELD ? ', ' : '; ') : String(v);
+        }
+        else
+            v = Array.isArray(v) ? String(v[0]) : String(v);
+        a.push(name, v);
+        return a;
+    }, []);
+}

package/cjs/utils/match-known-fields.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARRAY_FIELD = exports.SEMICOLON_DELIMITED_FIELD = exports.COMMA_DELIMITED_FIELD = exports.NO_DUPLICATES_FIELD = void 0;
+exports.matchKnownFields = matchKnownFields;
+const common_1 = require("@opra/common");
+exports.NO_DUPLICATES_FIELD = 0;
+exports.COMMA_DELIMITED_FIELD = 1;
+exports.SEMICOLON_DELIMITED_FIELD = 2;
+exports.ARRAY_FIELD = 3;
+const ARRAY_HEADERS = ['set-cookie'];
+const NO_DUPLICATES_HEADERS = [
+    'age',
+    'from',
+    'etag',
+    'server',
+    'referer',
+    'referrer',
+    'expires',
+    'location',
+    'user-agent',
+    'retry-after',
+    'content-type',
+    'content-length',
+    'max-forwards',
+    'last-modified',
+    'authorization',
+    'proxy-authorization',
+    'if-modified-since',
+    'if-unmodified-since',
+];
+const SEMICOLON_DELIMITED_HEADERS = ['cookie'];
+const KNOWN_FIELDS = Object.values(common_1.HttpHeaderCodes).reduce((o, k) => {
+    const n = k.toLowerCase();
+    o[n] = [
+        k,
+        NO_DUPLICATES_HEADERS.includes(n)
+            ? exports.NO_DUPLICATES_FIELD
+            : ARRAY_HEADERS.includes(n)
+                ? exports.ARRAY_FIELD
+                : SEMICOLON_DELIMITED_HEADERS.includes(n)
+                    ? exports.SEMICOLON_DELIMITED_FIELD
+                    : exports.COMMA_DELIMITED_FIELD,
+    ];
+    return o;
+}, {});
+function matchKnownFields(field) {
+    const x = KNOWN_FIELDS[field.toLowerCase()];
+    return x ? x : [field, exports.COMMA_DELIMITED_FIELD];
+}

package/cjs/utils/wrap-exception.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapException = wrapException;
+const common_1 = require("@opra/common");
+function wrapException(error) {
+    if (error instanceof common_1.OpraHttpError)
+        return error;
+    let status = 500;
+    if (typeof error.status === 'number')
+        status = error.status;
+    else if (typeof error.getStatus === 'function')
+        status = error.getStatus();
+    switch (status) {
+        case 400:
+            return new common_1.BadRequestError(error);
+        case 401:
+            return new common_1.UnauthorizedError(error);
+        case 403:
+            return new common_1.ForbiddenError(error);
+        case 404:
+            return new common_1.NotFoundError(error);
+        case 405:
+            return new common_1.MethodNotAllowedError(error);
+        case 406:
+            return new common_1.NotAcceptableError(error);
+        case 422:
+            return new common_1.UnprocessableEntityError(error);
+        case 424:
+            return new common_1.FailedDependencyError(error);
+        default:
+            return new common_1.InternalServerError(error);
+    }
+}

package/esm/express-adapter.js

@@ -0,0 +1,150 @@
+import * as nodePath from 'node:path';
+import { HttpApi, NotFoundError } from '@opra/common';
+import { Router } from 'express';
+import { HttpAdapter } from './http-adapter.js';
+import { HttpContext } from './http-context.js';
+import { HttpIncoming } from './interfaces/http-incoming.interface.js';
+import { HttpOutgoing } from './interfaces/http-outgoing.interface.js';
+import { wrapException } from './utils/wrap-exception.js';
+export class ExpressAdapter extends HttpAdapter {
+    constructor(app, document, options) {
+        super(document, options);
+        this._controllerInstances = new Map();
+        this.app = app;
+        if (!(this.document.api instanceof HttpApi))
+            throw new TypeError('document.api must be instance of HttpApi');
+        for (const c of this.api.controllers.values())
+            this._createControllers(c);
+        this._initRouter(options?.basePath);
+    }
+    get platform() {
+        return 'express';
+    }
+    async close() {
+        const processInstance = async (controller) => {
+            if (controller.controllers.size) {
+                const subResources = Array.from(controller.controllers.values());
+                subResources.reverse();
+                for (const subResource of subResources) {
+                    await processInstance(subResource);
+                }
+            }
+            if (controller.onShutdown) {
+                const instance = this._controllerInstances.get(controller) || controller.instance;
+                if (instance) {
+                    try {
+                        await controller.onShutdown.call(instance, controller);
+                    }
+                    catch (e) {
+                        if (this.listenerCount('error'))
+                            this.emit('error', wrapException(e));
+                    }
+                }
+            }
+        };
+        for (const c of this.api.controllers.values())
+            await processInstance(c);
+        this._controllerInstances.clear();
+    }
+    getControllerInstance(controllerPath) {
+        const controller = this.api.findController(controllerPath);
+        return controller && this._controllerInstances.get(controller);
+    }
+    _initRouter(basePath) {
+        const router = Router();
+        if (basePath) {
+            if (!basePath.startsWith('/'))
+                basePath = '/' + basePath;
+            if (basePath)
+                this.app.use(basePath, router);
+        }
+        else
+            this.app.use(router);
+        const createContext = async (_req, _res, args) => {
+            const request = HttpIncoming.from(_req);
+            const response = HttpOutgoing.from(_res);
+            const ctx = new HttpContext({
+                adapter: this,
+                platform: this.platform,
+                request,
+                response,
+                controller: args?.controller,
+                controllerInstance: args?.controllerInstance,
+                operation: args?.operation,
+                operationHandler: args?.operationHandler,
+            });
+            await this.emitAsync('createContext', ctx);
+            return ctx;
+        };
+        /** Add an endpoint that returns document schema */
+        router.get('/\\$schema', (_req, _res, next) => {
+            createContext(_req, _res)
+                .then(ctx => this.handler.sendDocumentSchema(ctx).catch(next))
+                .catch(next);
+        });
+        /** Add operation endpoints */
+        if (this.api.controllers.size) {
+            const processResource = (controller, currentPath) => {
+                currentPath = nodePath.join(currentPath, controller.path);
+                for (const operation of controller.operations.values()) {
+                    const routePath = currentPath + (operation.path || '');
+                    const controllerInstance = this._controllerInstances.get(controller);
+                    const operationHandler = controllerInstance[operation.name];
+                    if (!operationHandler)
+                        continue;
+                    /** Define router callback */
+                    router[operation.method.toLowerCase()](routePath, (_req, _res, _next) => {
+                        createContext(_req, _res, {
+                            controller,
+                            controllerInstance,
+                            operation,
+                            operationHandler,
+                        })
+                            .then(ctx => this.handler.handleRequest(ctx))
+                            .then(() => {
+                            if (!_res.headersSent)
+                                _next();
+                        })
+                            .catch((e) => this.emit('error', e));
+                    });
+                }
+                if (controller.controllers.size) {
+                    for (const child of controller.controllers.values())
+                        processResource(child, currentPath);
+                }
+            };
+            for (const c of this.api.controllers.values())
+                processResource(c, '/');
+        }
+        /** Add an endpoint that returns 404 error at last */
+        router.use('*', (_req, _res, next) => {
+            createContext(_req, _res)
+                .then(ctx => {
+                ctx.errors.push(new NotFoundError({
+                    message: `No endpoint found at [${_req.method}]${_req.baseUrl}`,
+                    details: {
+                        path: _req.baseUrl,
+                        method: _req.method,
+                    },
+                }));
+                this.handler.sendResponse(ctx).catch(next);
+            })
+                .catch(next);
+        });
+    }
+    _createControllers(controller) {
+        let instance = controller.instance;
+        if (!instance && controller.ctor)
+            instance = new controller.ctor();
+        if (instance) {
+            if (typeof controller.onInit === 'function')
+                controller.onInit.call(instance, controller);
+            this._controllerInstances.set(controller, instance);
+            // Initialize sub resources
+            for (const r of controller.controllers.values()) {
+                this._createControllers(r);
+            }
+        }
+        return instance;
+    }
+}

package/esm/http-adapter.js

@@ -0,0 +1,20 @@
+import { HttpApi } from '@opra/common';
+import { PlatformAdapter } from '@opra/core';
+import { HttpHandler } from './http-handler.js';
+/**
+ *
+ * @class HttpAdapter
+ */
+export class HttpAdapter extends PlatformAdapter {
+    constructor(document, options) {
+        super(document, options);
+        this.protocol = 'http';
+        if (!(document.api instanceof HttpApi))
+            throw new TypeError(`The document does not expose an HTTP Api`);
+        this.handler = new HttpHandler(this);
+        this.interceptors = [...(options?.interceptors || [])];
+    }
+    get api() {
+        return this.document.httpApi;
+    }
+}

package/esm/http-context.js

@@ -0,0 +1,98 @@
+import typeIs from '@browsery/type-is';
+import { InternalServerError, NotAcceptableError, } from '@opra/common';
+import { ExecutionContext, kAssetCache } from '@opra/core';
+import { vg } from 'valgen';
+import { MultipartReader } from './impl/multipart-reader.js';
+export class HttpContext extends ExecutionContext {
+    constructor(init) {
+        super({ ...init, document: init.adapter.document, protocol: 'http' });
+        this.adapter = init.adapter;
+        this.protocol = 'http';
+        if (init.controller)
+            this.controller = init.controller;
+        if (init.controllerInstance)
+            this.controllerInstance = init.controllerInstance;
+        if (init.operation)
+            this.operation = init.operation;
+        if (init.operationHandler)
+            this.operationHandler = init.operationHandler;
+        this.request = init.request;
+        this.response = init.response;
+        this.mediaType = init.mediaType;
+        this.cookies = init.cookies || {};
+        this.headers = init.headers || {};
+        this.pathParams = init.pathParams || {};
+        this.queryParams = init.queryParams || {};
+        this._body = init.body;
+        this.on('finish', () => {
+            if (this._multipartReader)
+                this._multipartReader.purge().catch(() => undefined);
+        });
+    }
+    get isMultipart() {
+        return !!this.request.is('multipart');
+    }
+    async getMultipartReader() {
+        if (!this.isMultipart)
+            throw new InternalServerError('Request content is not a multipart content');
+        if (this._multipartReader)
+            return this._multipartReader;
+        const { mediaType } = this;
+        if (mediaType?.contentType) {
+            const arr = Array.isArray(mediaType.contentType) ? mediaType.contentType : [mediaType.contentType];
+            const contentType = arr.find(ct => typeIs.is(ct, ['multipart']));
+            if (!contentType)
+                throw new NotAcceptableError('This endpoint does not accept multipart requests');
+        }
+        const reader = new MultipartReader(this, {
+            limits: {
+                fields: mediaType?.maxFields,
+                fieldSize: mediaType?.maxFieldsSize,
+                files: mediaType?.maxFiles,
+                fileSize: mediaType?.maxFileSize,
+            },
+        }, mediaType);
+        this._multipartReader = reader;
+        return reader;
+    }
+    async getBody() {
+        if (this._body !== undefined)
+            return this._body;
+        const { request, operation, mediaType } = this;
+        if (this.isMultipart) {
+            const reader = await this.getMultipartReader();
+            /** Retrieve all fields */
+            const parts = await reader.getAll();
+            /** Filter fields according to configuration */
+            this._body = [...parts];
+            return this._body;
+        }
+        this._body = await this.request.readBody({ limit: operation?.requestBody?.maxContentSize });
+        if (this._body != null) {
+            // Convert Buffer to string if media is text
+            if (Buffer.isBuffer(this._body) && request.is(['json', 'xml', 'txt', 'text'])) {
+                this._body = this._body.toString('utf-8');
+            }
+            // Transform text to Object if media is JSON
+            if (typeof this._body === 'string' && request.is(['json']))
+                this._body = JSON.parse(this._body);
+        }
+        if (mediaType) {
+            // Decode/Validate the data object according to data model
+            if (this._body && mediaType.type) {
+                let decode = this.adapter[kAssetCache].get(mediaType, 'decode');
+                if (!decode) {
+                    decode =
+                        mediaType.type?.generateCodec('decode', {
+                            partial: operation?.requestBody?.partial,
+                            projection: '*',
+                            ignoreReadonlyFields: true,
+                        }) || vg.isAny();
+                    this.adapter[kAssetCache].set(mediaType, 'decode', decode);
+                }
+                this._body = decode(this._body);
+            }
+        }
+        return this._body;
+    }
+}