@opra/core 0.33.13 → 1.0.0-alpha.10

package/esm/http/utils/body-reader.js

@@ -0,0 +1,212 @@
+import typeIs from '@browsery/type-is';
+import { BadRequestError, InternalServerError, OpraHttpError } from '@opra/common';
+import { Base64Decode } from 'base64-stream';
+import byteParser from 'bytes';
+import { parse as parseContentType } from 'content-type';
+import { EventEmitter } from 'events';
+import iconv from 'iconv-lite';
+import { Writable } from 'stream';
+import * as zlib from 'zlib';
+/**
+ *
+ * @class BodyReader
+ */
+export class BodyReader extends EventEmitter {
+    constructor(req, options) {
+        super();
+        this.req = req;
+        this._completed = false;
+        this._receivedSize = 0;
+        this.onAborted = () => this._onAborted();
+        this.onData = (chunk) => this._onData(chunk);
+        this.onEnd = (err) => this._onEnd(err);
+        this.cleanup = () => this._cleanup();
+        this.limit = options?.limit
+            ? typeof options.limit === 'number'
+                ? options.limit
+                : byteParser(options.limit)
+            : undefined;
+    }
+    async read() {
+        /* istanbul ignore next */
+        if (this._completed) {
+            throw new InternalServerError({
+                message: 'Stream already read',
+                code: 'STREAM_ALREADY_READ',
+            });
+        }
+        if (!this.req.readable) {
+            throw new InternalServerError({
+                message: 'Stream is not readable',
+                code: 'STREAM_NOT_READABLE',
+            });
+        }
+        return new Promise((resolve, reject) => {
+            // eslint-disable-next-line prefer-const
+            let sizeStream;
+            this.once('finish', (error, data) => {
+                if (sizeStream)
+                    this.req.unpipe(sizeStream);
+                if (error)
+                    return reject(error);
+                resolve(data);
+            });
+            /**
+             * Check if a request has a request body.
+             * A request with a body __must__ either have `transfer-encoding`
+             * or `content-length` headers set.
+             * http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
+             */
+            const contentLength = parseInt(this.req.headers['content-length'] || '0', 10);
+            if (this.req.headers['transfer-encoding'] === undefined && !(contentLength && !isNaN(contentLength))) {
+                return this.onEnd();
+            }
+            // check the length and limit options.
+            // note: we intentionally leave the stream paused,
+            // so users should handle the stream themselves.
+            if (this.limit != null && contentLength != null && contentLength > this.limit) {
+                return this.onEnd(new OpraHttpError({
+                    message: 'Content Too Large',
+                    code: 'HTTP.CONTENT_TOO_LARGE',
+                    details: {
+                        length: contentLength,
+                        limit: this.limit,
+                    },
+                }, 413));
+            }
+            // Pipe to a Writable stream to count received bytes
+            const _this = this;
+            sizeStream = new Writable({
+                write(chunk, encoding, callback) {
+                    if (_this._completed)
+                        return;
+                    _this._receivedSize += chunk.length;
+                    if (_this.limit != null && _this._receivedSize > _this.limit) {
+                        callback(new OpraHttpError({
+                            message: 'Content Too Large',
+                            code: 'HTTP.CONTENT_TOO_LARGE',
+                            details: {
+                                limit: _this.limit,
+                                received: _this._receivedSize,
+                            },
+                        }, 413));
+                    }
+                },
+            });
+            this.req.pipe(sizeStream);
+            let stream = BodyReader.encoderPipeline(this.req);
+            const mediaType = parseContentType(this.req.headers['content-type'] || '');
+            let charset = (mediaType.parameters.charset || '').toLowerCase();
+            if (!charset && typeIs.is(mediaType.type, ['json', 'xml', 'txt']))
+                charset = 'utf-8';
+            if (charset) {
+                const newStream = iconv.decodeStream(charset);
+                stream.pipe(newStream);
+                stream = newStream;
+            }
+            this._stream = stream;
+            // attach listeners
+            stream.on('aborted', this.onAborted);
+            stream.on('close', this.cleanup);
+            stream.on('data', this.onData);
+            stream.on('end', this.onEnd);
+            stream.on('error', this.onEnd);
+        });
+    }
+    _onEnd(error) {
+        if (this._completed)
+            return;
+        this._completed = true;
+        if (error) {
+            this._stream?.unpipe();
+            this._stream?.pause();
+        }
+        if (error)
+            this.emit('finish', error);
+        else if (Array.isArray(this._buffer))
+            this.emit('finish', error, Buffer.concat(this._buffer));
+        else
+            this.emit('finish', error, this._buffer);
+        this._cleanup();
+    }
+    _cleanup() {
+        if (this._stream) {
+            this._stream.removeListener('aborted', this.onAborted);
+            this._stream.removeListener('close', this.cleanup);
+            this._stream.removeListener('data', this.onData);
+            this._stream.removeListener('end', this.onEnd);
+            this._stream.removeListener('error', this.onEnd);
+        }
+    }
+    _onAborted() {
+        if (this._completed)
+            return;
+        this.onEnd(new BadRequestError({
+            message: 'request aborted',
+            code: 'ECONNABORTED',
+            details: {
+                length,
+                received: this._receivedSize,
+            },
+        }));
+    }
+    _onData(chunk) {
+        if (this._completed)
+            return;
+        if (typeof chunk === 'string') {
+            this._buffer = this._buffer || '';
+            this._buffer += chunk;
+        }
+        else {
+            this._buffer = this._buffer || [];
+            this._buffer.push(chunk);
+        }
+    }
+    static async read(req, options) {
+        const bodyReady = new BodyReader(req, options);
+        return bodyReady.read();
+    }
+    static encoderPipeline(req) {
+        const contentEncoding = req.headers['content-encoding'] || 'identity';
+        const contentEncodings = (Array.isArray(contentEncoding) ? contentEncoding : contentEncoding.split(/\s*,\s*/))
+            .map(s => s.toLowerCase())
+            .reverse();
+        return contentEncodings.reduce((prev, encoding) => {
+            switch (encoding) {
+                case 'gzip':
+                case 'x-gzip': {
+                    const newStream = zlib.createGunzip();
+                    prev.pipe(newStream);
+                    return newStream;
+                }
+                case 'deflate':
+                case 'x-deflate': {
+                    const newStream = zlib.createInflate();
+                    prev.pipe(newStream);
+                    return newStream;
+                }
+                case 'br': {
+                    const newStream = zlib.createBrotliDecompress();
+                    prev.pipe(newStream);
+                    return newStream;
+                }
+                case 'base64': {
+                    const newStream = new Base64Decode();
+                    prev.pipe(newStream);
+                    return newStream;
+                }
+                case 'identity':
+                    // prev.length = 0;
+                    return prev;
+                default:
+                    throw new BadRequestError({
+                        message: 'unsupported content encoding "' + encoding + '"',
+                        code: '',
+                        details: {
+                            encoding,
+                        },
+                    }, 415);
+            }
+        }, req);
+    }
+}

package/esm/http/{helpers → utils}/common.js

@@ -55,6 +55,7 @@ export const validateHeaderValue = hideStackFrames((name, value) => {
     }
 });
 export function validateString(value, name) {
-    if (typeof value !== 'string')
+    if (typeof value !== 'string') {
         throw new TypeError(`Invalid ${name ? name + ' ' : ''}argument. Value must be a string`);
+    }
 }

package/esm/http/{helpers → utils}/convert-to-headers.js

@@ -1,4 +1,4 @@
-import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD } from './match-known-fields.js';
+import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD, } from './match-known-fields.js';
 export function convertToHeaders(src, dst, joinDuplicateHeaders) {
     for (let n = 0; n < src.length; n += 2) {
         addHeaderLine(src[n], src[n + 1], dst, joinDuplicateHeaders);

package/esm/http/{helpers → utils}/convert-to-raw-headers.js

@@ -1,7 +1,6 @@
-import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD } from './match-known-fields.js';
+import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD, } from './match-known-fields.js';
 export function convertToRawHeaders(src) {
-    return Object.entries(src)
-        .reduce((a, [field, v]) => {
+    return Object.entries(src).reduce((a, [field, v]) => {
         const [name, flag] = matchKnownFields(field);
         if (flag === ARRAY_FIELD) {
             if (Array.isArray(v))

package/esm/http/{helpers → utils}/match-known-fields.js

@@ -3,9 +3,7 @@ export const NO_DUPLICATES_FIELD = 0;
 export const COMMA_DELIMITED_FIELD = 1;
 export const SEMICOLON_DELIMITED_FIELD = 2;
 export const ARRAY_FIELD = 3;
-const ARRAY_HEADERS = [
-    'set-cookie'
-];
+const ARRAY_HEADERS = ['set-cookie'];
 const NO_DUPLICATES_HEADERS = [
     'age',
     'from',
@@ -27,13 +25,17 @@ const NO_DUPLICATES_HEADERS = [
     'if-unmodified-since',
 ];
 const SEMICOLON_DELIMITED_HEADERS = ['cookie'];
-const KNOWN_FIELDS = Object.values(HttpHeaderCodes)
-    .reduce((o, k) => {
+const KNOWN_FIELDS = Object.values(HttpHeaderCodes).reduce((o, k) => {
     const n = k.toLowerCase();
-    o[n] = [k,
-        (NO_DUPLICATES_HEADERS.includes(n) ? NO_DUPLICATES_FIELD :
-            (ARRAY_HEADERS.includes(n) ? ARRAY_FIELD :
-                (SEMICOLON_DELIMITED_HEADERS.includes(n) ? SEMICOLON_DELIMITED_FIELD : COMMA_DELIMITED_FIELD)))
+    o[n] = [
+        k,
+        NO_DUPLICATES_HEADERS.includes(n)
+            ? NO_DUPLICATES_FIELD
+            : ARRAY_HEADERS.includes(n)
+                ? ARRAY_FIELD
+                : SEMICOLON_DELIMITED_HEADERS.includes(n)
+                    ? SEMICOLON_DELIMITED_FIELD
+                    : COMMA_DELIMITED_FIELD,
     ];
     return o;
 }, {});

package/esm/http/utils/wrap-exception.js

@@ -0,0 +1,30 @@
+import { BadRequestError, FailedDependencyError, ForbiddenError, InternalServerError, MethodNotAllowedError, NotAcceptableError, NotFoundError, OpraHttpError, UnauthorizedError, UnprocessableEntityError, } from '@opra/common';
+export function wrapException(error) {
+    if (error instanceof 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 BadRequestError(error);
+        case 401:
+            return new UnauthorizedError(error);
+        case 403:
+            return new ForbiddenError(error);
+        case 404:
+            return new NotFoundError(error);
+        case 405:
+            return new MethodNotAllowedError(error);
+        case 406:
+            return new NotAcceptableError(error);
+        case 422:
+            return new UnprocessableEntityError(error);
+        case 424:
+            return new FailedDependencyError(error);
+        default:
+            return new InternalServerError(error);
+    }
+}

package/esm/index.js

@@ -1,30 +1,29 @@
-import "reflect-metadata";
+import 'reflect-metadata';
 import './augmentation/18n.augmentation.js';
-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';
+import './augmentation/http-controller.augmentation.js';
+import * as HttpIncomingHost_ from './http/impl/http-incoming.host.js';
+import * as HttpOutgoingHost_ from './http/impl/http-outgoing.host.js';
+import * as NodeIncomingMessageHost_ from './http/impl/node-incoming-message.host.js';
+import * as NodeOutgoingMessageHost_ from './http/impl/node-outgoing-message.host.js';
 export * from './execution-context.js';
-export * from './execution-context.host.js';
-export * from './platform-adapter.js';
-export * from './platform-adapter.host.js';
-export * from './request.js';
-export * from './request.host.js';
-export * from './request-context.js';
-export * from './response.js';
-export * from './response.host.js';
-export * from './http/adapters/express-adapter.js';
-export * from './http/adapters/express-adapter.host.js';
-export * from './http/adapters/node-http-adapter.js';
-export * from './http/adapters/node-http-adapter.host.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';
-export * from './http/http-server-response.js';
-export * from './http/helpers/multipart-helper.js';
-export * from './interfaces/interceptor.interface.js';
+export * from './helpers/logger.js';
+export * from './helpers/service-base.js';
+export * from './http/express-adapter.js';
+export * from './http/http-adapter.js';
+export * from './http/http-context.js';
+export * from './http/impl/multipart-reader.js';
+export * from './http/interfaces/http-incoming.interface.js';
+export * from './http/interfaces/http-outgoing.interface.js';
+export * from './http/interfaces/node-incoming-message.interface.js';
+export * from './http/interfaces/node-outgoing-message.interface.js';
+export * from './http/utils/wrap-exception.js';
 export * from './interfaces/logger.interface.js';
-export * from './interfaces/request-handler.interface.js';
-export * from './services/logger.js';
-export * from './services/api-service.js';
+export * from './platform-adapter.js';
+export * from './type-guards.js';
+export var classes;
+(function (classes) {
+    classes.HttpIncomingHost = HttpIncomingHost_.HttpIncomingHost;
+    classes.HttpOutgoingHost = HttpOutgoingHost_.HttpOutgoingHost;
+    classes.NodeIncomingMessageHost = NodeIncomingMessageHost_.NodeIncomingMessageHost;
+    classes.NodeOutgoingMessageHost = NodeOutgoingMessageHost_.NodeOutgoingMessageHost;
+})(classes || (classes = {}));

package/esm/platform-adapter.js

@@ -1 +1,19 @@
-export {};
+import './augmentation/18n.augmentation.js';
+import { I18n } from '@opra/common';
+import { AsyncEventEmitter } from 'strict-typed-events';
+import { kAssetCache } from './constants.js';
+import { Logger } from './helpers/logger.js';
+import { AssetCache } from './http/impl/asset-cache.js';
+/**
+ * @class PlatformAdapter
+ */
+export class PlatformAdapter extends AsyncEventEmitter {
+    constructor(document, options) {
+        super();
+        this[kAssetCache] = new AssetCache();
+        this.document = document;
+        this.logger =
+            options?.logger && options.logger instanceof Logger ? options.logger : new Logger({ instance: options?.logger });
+        this.i18n = options?.i18n || I18n.defaultInstance;
+    }
+}

package/esm/type-guards.js

@@ -0,0 +1,16 @@
+import { isReadable, isStream } from '@opra/common';
+export function isNodeIncomingMessage(v) {
+    return v && typeof v.method === 'string' && Array.isArray(v.rawHeaders) && isReadable(v);
+}
+export function isHttpIncoming(v) {
+    return (isNodeIncomingMessage(v) &&
+        typeof v.header === 'function' &&
+        typeof v.acceptsLanguages === 'function' &&
+        typeof v.readBody === 'function');
+}
+export function isNodeOutgoingMessage(v) {
+    return v && typeof v.getHeaders === 'function' && isStream(v);
+}
+export function isHttpOutgoing(v) {
+    return isNodeOutgoingMessage(v) && typeof v.clearCookie === 'function' && typeof v.cookie === 'function';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.33.13",
+  "version": "1.0.0-alpha.10",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -19,8 +19,11 @@
     "_copy_pkg_files": "cp README.md package.json ../../LICENSE ../../build/core && cp ../../package.cjs.json ../../build/core/cjs/package.json",
     "_copyi18n": "cp -R i18n ../../build/core/i18n",
     "lint": "eslint . --max-warnings=0",
-    "test": "jest",
-    "cover": "jest --collect-coverage",
+    "lint:fix": "eslint . --max-warnings=0 --fix",
+    "format": "prettier . --write --log-level=warn",
+    "check": "madge --circular src/**",
+    "test": "jest --passWithNoTests",
+    "cover": "jest --passWithNoTests --collect-coverage",
     "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
     "clean:src": "ts-cleanup -s src --all",
     "clean:test": "ts-cleanup -s test --all",
@@ -28,45 +31,60 @@
     "clean:cover": "rimraf ../../coverage/client"
   },
   "dependencies": {
-    "@browsery/type-is": "^0.6.3",
-    "@opra/common": "^0.33.13",
+    "@browsery/http-parser": "^0.5.8",
+    "@browsery/type-is": "^1.6.18-r2",
+    "@opra/common": "^1.0.0-alpha.10",
     "@types/formidable": "^3.4.5",
     "accepts": "^1.3.8",
+    "base64-stream": "^1.0.0",
+    "bytes": "^3.1.2",
     "content-disposition": "^0.5.4",
     "content-type": "^1.0.5",
     "cookie": "^0.6.0",
     "cookie-signature": "^1.2.1",
-    "encodeurl": "^1.0.2",
+    "cppzst": "^2.0.12",
+    "encodeurl": "^2.0.0",
     "formidable": "^3.5.1",
     "fresh": "^0.5.2",
+    "iconv-lite": "^0.6.3",
     "mime-types": "^2.1.35",
-    "power-tasks": "^1.7.3",
+    "power-tasks": "^1.7.4",
     "putil-isplainobject": "^1.1.5",
+    "putil-merge": "^3.12.1",
     "putil-varhelpers": "^1.6.5",
     "range-parser": "^1.2.1",
+    "raw-body": "^2.5.2",
+    "reflect-metadata": "^0.2.2",
     "strict-typed-events": "^2.3.3",
     "vary": "^1.1.2"
   },
-  "peerDependencies": {
-    "express": "^4.x.x || ^5.x.x"
+  "optionalDependencies": {
+    "express": "^4.x.x || ^5.x.x",
+    "fastify": "^4.x.x"
   },
   "devDependencies": {
-    "@faker-js/faker": "^8.4.0",
+    "@faker-js/faker": "^8.4.1",
     "@types/accepts": "^1.3.7",
+    "@types/base64-stream": "^1.0.5",
+    "@types/bytes": "^3.1.4",
     "@types/content-disposition": "^0.5.8",
     "@types/content-type": "^1.1.8",
     "@types/cookie": "^0.6.0",
+    "@types/cookie-parser": "^1.4.7",
     "@types/cookie-signature": "^1.1.2",
     "@types/encodeurl": "^1.0.2",
     "@types/express": "^4.17.21",
     "@types/fresh": "^0.5.2",
     "@types/mime-types": "^2.1.4",
     "@types/range-parser": "^1.2.7",
-    "@types/type-is": "^1.6.6",
     "@types/vary": "^1.1.3",
+    "cookie-parser": "^1.4.6",
     "crypto-browserify": "^3.12.0",
+    "express": "^4.19.2",
+    "fastify": "^4.28.1",
     "path-browserify": "^1.0.1",
-    "ts-gems": "^3.1.1"
+    "supertest": "^7.0.0",
+    "ts-gems": "^3.4.0"
   },
   "type": "module",
   "module": "./esm/index.js",
@@ -95,4 +113,4 @@
     "swagger",
     "raml"
   ]
-}
+}

package/types/augmentation/18n.augmentation.d.ts

@@ -1,7 +1,37 @@
-declare module "@opra/common" {
+declare module '@opra/common' {
     interface I18n {
         loadResourceDir(dirnames: string | string[], deep?: boolean, overwrite?: boolean): Promise<void>;
         loadResourceBundle(lang: string, ns: string, filePath: string, deep?: boolean, overwrite?: boolean): Promise<void>;
     }
+    namespace I18n {
+        function load(): Promise<I18n>;
+        interface Options {
+            /**
+             * Language to use
+             * @default undefined
+             */
+            lng?: string;
+            /**
+             * Language to use if translations in user language are not available.
+             * @default 'dev'
+             */
+            fallbackLng?: false | FallbackLng;
+            /**
+             * Default namespace used if not passed to translation function
+             * @default 'translation'
+             */
+            defaultNS?: string;
+            /**
+             * Resources to initialize with
+             * @default undefined
+             */
+            resources?: LanguageResource;
+            /**
+             * Resource directories to initialize with (if not using loading or not appending using addResourceBundle)
+             * @default undefined
+             */
+            resourceDirs?: string[];
+        }
+    }
 }
 export {};

package/types/augmentation/http-controller.augmentation.d.ts

@@ -0,0 +1,21 @@
+import type { HttpContext } from '../http/http-context';
+declare module '@opra/common' {
+    interface HttpControllerStatic {
+        OnInit(): PropertyDecorator;
+        OnShutdown(): PropertyDecorator;
+    }
+    interface HttpController {
+        onInit?: (resource: HttpController) => void;
+        onShutdown?: (resource: HttpController) => void | Promise<void>;
+    }
+    namespace HttpController {
+        interface InitArguments {
+            onInit?: (resource: HttpController) => void;
+            onShutdown?: (resource: HttpController) => void | Promise<void>;
+        }
+    }
+    namespace HttpOperation {
+        interface Context extends HttpContext {
+        }
+    }
+}

package/types/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const kHandler: unique symbol;
+export declare const kAssetCache: unique symbol;

package/types/execution-context.d.ts

@@ -1,30 +1,26 @@
-import type { HttpServerRequest } from './http/http-server-request.js';
-import type { HttpServerResponse } from './http/http-server-response.js';
-import type { Protocol } from './platform-adapter.js';
-export interface ExecutionContext {
-    readonly protocol: Protocol;
-    readonly platform: string;
-    switchToHttp(): HttpMessageContext;
-    switchToWs(): WsMessageContext;
-    switchToRpc(): RpcMessageContext;
-    on(event: 'finish', fn: (args: ExecutionContext.OnFinishArgs) => void | Promise<void>): any;
-}
+import { ApiDocument, OpraSchema } from '@opra/common';
+import { AsyncEventEmitter } from 'strict-typed-events';
+/**
+ * @namespace ExecutionContext
+ */
 export declare namespace ExecutionContext {
-    type OnFinishArgs = {
-        context: ExecutionContext;
-        failed: boolean;
-    };
-    function is(v: any): boolean;
+    interface Initiator {
+        document: ApiDocument;
+        protocol: OpraSchema.Protocol;
+        platform: string;
+    }
+    type OnFinishListener = (error: Error | undefined, context: ExecutionContext) => void | Promise<void>;
 }
-export interface HttpMessageContext {
+/**
+ * @class ExecutionContext
+ */
+export declare abstract class ExecutionContext extends AsyncEventEmitter {
+    readonly document: ApiDocument;
+    readonly protocol: OpraSchema.Protocol;
     readonly platform: string;
-    readonly incoming: HttpServerRequest;
-    readonly outgoing: HttpServerResponse;
-    switchToContext(): ExecutionContext;
-}
-export interface WsMessageContext {
-    switchToContext(): ExecutionContext;
-}
-export interface RpcMessageContext {
-    switchToContext(): ExecutionContext;
+    protected constructor(init: ExecutionContext.Initiator);
+    addListener(event: 'finish', listener: ExecutionContext.OnFinishListener): this;
+    removeListener(event: 'finish', listener: ExecutionContext.OnFinishListener): this;
+    on(event: 'finish', listener: ExecutionContext.OnFinishListener): this;
+    off(event: 'finish', listener: ExecutionContext.OnFinishListener): this;
 }

package/types/helpers/service-base.d.ts

@@ -0,0 +1,10 @@
+import { Nullish } from 'ts-gems';
+import type { HttpContext } from '../http/http-context';
+export declare abstract class ServiceBase {
+    protected _context: HttpContext;
+    get context(): HttpContext;
+    for<C extends HttpContext, P extends Partial<this>>(context: C, overwriteProperties?: Nullish<P>, overwriteContext?: Partial<C>): this & Required<P>;
+}
+export declare namespace ServiceBase {
+    const extendSymbol: unique symbol;
+}

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

@@ -0,0 +1,13 @@
+import { ApiDocument, HttpController } from '@opra/common';
+import { Application } from 'express';
+import { HttpAdapter } from './http-adapter.js';
+export declare class ExpressAdapter extends HttpAdapter {
+    readonly app: Application;
+    protected _controllerInstances: Map<HttpController, any>;
+    constructor(app: Application, document: ApiDocument, options?: HttpAdapter.Options);
+    get platform(): string;
+    close(): Promise<void>;
+    getControllerInstance<T>(controllerPath: string): T | undefined;
+    protected _initRouter(basePath?: string): void;
+    protected _createControllers(controller: HttpController): void;
+}