@opra/core 0.33.13 → 1.0.0-alpha.2

package/types/http/impl/{http-incoming-message.host.d.ts → node-incoming-message.host.d.ts}

@@ -2,39 +2,26 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import http, { IncomingHttpHeaders } from 'http';
+import { IncomingHttpHeaders } from 'http';
 import { Duplex, Readable } from 'stream';
 import { HTTPParserJS } from '@browsery/http-parser';
+import type { NodeIncomingMessage } from '../interfaces/node-incoming-message.interface';
 export declare const CRLF: Buffer;
 export declare const kHeaders: unique symbol;
 export declare const kHeadersDistinct: unique symbol;
 export declare const kTrailers: unique symbol;
 export declare const kTrailersDistinct: unique symbol;
-export interface HttpIncomingMessage extends Pick<http.IncomingMessage, 'httpVersion' | 'httpVersionMajor' | 'httpVersionMinor' | 'complete' | 'headers' | 'trailers' | 'rawHeaders' | 'rawTrailers' | 'method' | 'url'>, Readable {
-}
-export declare namespace HttpIncomingMessageHost {
-    interface Initiator {
-        httpVersionMajor?: number;
-        httpVersionMinor?: number;
-        method?: string;
-        url?: string;
-        headers?: Record<string, any> | string[];
-        trailers?: Record<string, any> | string[];
-        body?: any;
-        ip?: string;
-        ips?: string[];
-    }
-}
+export declare const kHttpParser: unique symbol;
 /**
  *
- * @class HttpIncomingMessageHost
+ * @class NodeIncomingMessageHost
  */
-export declare class HttpIncomingMessageHost extends Duplex implements HttpIncomingMessage {
+export declare class NodeIncomingMessageHost extends Duplex implements NodeIncomingMessage {
     protected [kHeaders]?: IncomingHttpHeaders;
     protected [kHeadersDistinct]?: NodeJS.Dict<string[]>;
     protected [kTrailers]?: NodeJS.Dict<string>;
     protected [kTrailersDistinct]?: NodeJS.Dict<string[]>;
-    protected _httpParser: HTTPParserJS | undefined;
+    protected [kHttpParser]: HTTPParserJS | undefined;
     protected _readStream?: Readable;
     httpVersionMajor: number;
     httpVersionMinor: number;
@@ -42,12 +29,14 @@ export declare class HttpIncomingMessageHost extends Duplex implements HttpIncom
     url: string;
     rawHeaders: string[];
     rawTrailers: string[];
+    params?: Record<string, any>;
+    cookies?: Record<string, any>;
     body?: Buffer;
     complete: boolean;
     ip?: string;
     ips?: string[];
     joinDuplicateHeaders: boolean;
-    constructor(init?: HttpIncomingMessageHost.Initiator);
+    constructor(init?: NodeIncomingMessage.Initiator);
     get httpVersion(): string;
     get headers(): IncomingHttpHeaders;
     set headers(headers: IncomingHttpHeaders);
@@ -57,6 +46,4 @@ export declare class HttpIncomingMessageHost extends Duplex implements HttpIncom
     get trailersDistinct(): NodeJS.Dict<string[]>;
     _read(size: number): void;
     _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-    static from(iterable: string | Iterable<any> | AsyncIterable<any> | HttpIncomingMessageHost.Initiator): HttpIncomingMessageHost;
-    static fromAsync(iterable: string | Iterable<any> | AsyncIterable<any> | HttpIncomingMessageHost.Initiator): Promise<HttpIncomingMessageHost>;
 }

package/types/http/impl/{http-outgoing-message.host.d.ts → node-outgoing-message.host.d.ts}

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import http, { OutgoingHttpHeaders } from 'http';
-import { Duplex, Writable } from 'stream';
-import type { HttpIncomingMessage } from './http-incoming-message.host.js';
+import { OutgoingHttpHeaders } from 'http';
+import { Duplex } from 'stream';
+import type { NodeIncomingMessage } from '../interfaces/node-incoming-message.interface';
+import type { NodeOutgoingMessage } from '../interfaces/node-outgoing-message.interface';
 export declare const kOutHeaders: unique symbol;
 export declare const kOutTrailers: unique symbol;
 declare global {
@@ -12,57 +13,40 @@ declare global {
         entries(): IterableIterator<[string, any]>;
     }
 }
-export interface HttpOutgoingMessage extends Pick<http.ServerResponse, 'addTrailers' | 'getHeader' | 'getHeaders' | 'getHeaderNames' | 'removeHeader' | 'hasHeader' | 'headersSent' | 'statusCode' | 'statusMessage' | 'sendDate'>, Writable {
-    req?: HttpIncomingMessage;
-    appendHeader(name: string, value: string | readonly string[]): this;
-    setHeader(name: string, value: number | string | readonly string[]): this;
-}
-export declare namespace HttpOutgoingMessageHost {
-    interface Initiator {
-        req?: HttpIncomingMessage;
-        statusCode?: number;
-        statusMessage?: string;
-        headers?: OutgoingHttpHeaders | Headers | Map<string, any> | string[];
-        chunkedEncoding?: boolean;
-        sendDate?: boolean;
-        strictContentLength?: boolean;
-        body?: string | Iterable<any> | AsyncIterable<any> | Object;
-    }
-}
 /**
  *
- * @class HttpOutgoingMessageHost
+ * @class NodeOutgoingMessageHost
  */
-export declare class HttpOutgoingMessageHost extends Duplex implements HttpOutgoingMessage {
+export declare class NodeOutgoingMessageHost extends Duplex implements NodeOutgoingMessage {
     protected [kOutHeaders]: Record<string, any>;
     protected [kOutTrailers]: Record<string, any>;
     protected _headersSent: boolean;
     protected _httpVersionMajor?: number;
     protected _httpVersionMinor?: number;
     finished: boolean;
-    req?: HttpIncomingMessage;
+    req: NodeIncomingMessage;
     statusCode: number;
     statusMessage: string;
     chunkedEncoding: boolean;
     sendDate: boolean;
     strictContentLength: boolean;
     body?: any;
-    constructor(init?: HttpOutgoingMessageHost.Initiator);
+    constructor(init?: NodeOutgoingMessage.Initiator);
     get httpVersionMajor(): number | undefined;
     get httpVersionMinor(): number | undefined;
     get headersSent(): boolean;
     appendHeader(name: string, value: number | string | readonly string[]): this;
     addTrailers(headers: OutgoingHttpHeaders | [string, string][] | readonly [string, string][]): void;
-    setHeader(name: any, value: any): this;
+    flushHeaders(): void;
+    setHeader(name: string, value: number | string | readonly string[]): this;
     setHeaders(headers: Headers | Map<string, any> | Record<string, any>): this;
     getHeader(name: string): any;
     getHeaderNames(): string[];
-    getRawHeaderNames(): any[];
+    getRawHeaderNames(): string[];
     getHeaders(): OutgoingHttpHeaders;
     hasHeader(name: string): boolean;
     removeHeader(name: string): void;
     end(cb?: () => void): this;
     end(chunk: any, cb?: () => void): this;
     end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
-    static from(init: HttpOutgoingMessageHost.Initiator): HttpOutgoingMessageHost;
 }

package/types/http/{http-server-request.d.ts → interfaces/http-incoming.interface.d.ts}

@@ -1,17 +1,15 @@
+/// <reference types="node" />
 import { Options as RangeParserOptions, Ranges as RangeParserRanges, Result as RangeParserResult } from 'range-parser';
-import { OpraURL } from '@opra/common';
-import type { HttpServerResponse } from './http-server-response';
-import { HttpIncomingMessage, HttpIncomingMessageHost } from './impl/http-incoming-message.host.js';
-export declare namespace HttpServerRequest {
-    function from(instance: HttpIncomingMessage | HttpIncomingMessageHost.Initiator | string | Iterable<any> | AsyncIterable<any>): HttpServerRequest;
-}
-export interface HttpServerRequest extends HttpIncomingMessage {
-    res: HttpServerResponse;
+import { BodyReader } from '../utils/body-reader.js';
+import type { HttpOutgoing } from './http-outgoing.interface';
+import { NodeIncomingMessage } from './node-incoming-message.interface.js';
+/**
+ * @interface HttpIncoming
+ */
+export interface HttpIncoming extends NodeIncomingMessage {
+    res: HttpOutgoing;
     baseUrl: string;
     originalUrl: string;
-    parsedUrl: OpraURL;
-    searchParams: URLSearchParams;
-    body?: any;
     /**
      * Return the protocol string "http" or "https"
      * When the "X-Forwarded-Proto" header field will be trusted
@@ -38,6 +36,10 @@ export interface HttpServerRequest extends HttpIncomingMessage {
      *    req.protocol === 'https'
      */
     secure: boolean;
+    /**
+     * Used for signed cookies
+     */
+    secret?: string;
     /**
      * Parse the "Host" header field to a hostname.
      *
@@ -52,15 +54,13 @@ export interface HttpServerRequest extends HttpIncomingMessage {
      */
     fresh: boolean;
     /**
-     * Check if the request was an _XMLHttpRequest_.
-     *
+     * Path parameter values
      */
-    xhr: boolean;
+    params: Record<string, any>;
     /**
-     * Secret value for cookie encryption
-     *
+     * Cookie parameter values
      */
-    secret?: string;
+    cookies?: Record<string, any>;
     /**
      * Return request header.
      *
@@ -179,4 +179,15 @@ export interface HttpServerRequest extends HttpIncomingMessage {
      * Parse Range header field, capping to the given `size`.
      */
     range(size: number, options?: RangeParserOptions): RangeParserRanges | RangeParserResult | undefined;
+    /**
+     * Receives the body
+     * @param options
+     */
+    readBody(options: BodyReader.Options): Promise<string | Buffer | undefined>;
+}
+/**
+ * @namespace HttpIncoming
+ */
+export declare namespace HttpIncoming {
+    function from(instance: HttpIncoming | NodeIncomingMessage.Initiator | string | Iterable<any> | AsyncIterable<any>): HttpIncoming;
 }

package/types/http/{http-server-response.d.ts → interfaces/http-outgoing.interface.d.ts}

@@ -1,14 +1,15 @@
-import type { HttpServerRequest } from './http-server-request.js';
-import { HttpOutgoingMessage, HttpOutgoingMessageHost } from './impl/http-outgoing-message.host.js';
-export declare namespace HttpServerResponse {
-    function from(instance?: HttpOutgoingMessage | HttpOutgoingMessageHost.Initiator): HttpServerResponse;
-}
-export interface HttpServerResponse extends HttpOutgoingMessage {
-    req?: HttpServerRequest;
+import { StrictOmit } from 'ts-gems';
+import type { HttpIncoming } from './http-incoming.interface';
+import { NodeOutgoingMessage } from './node-outgoing-message.interface.js';
+export interface HttpOutgoing extends StrictOmit<NodeOutgoingMessage, 'req' | 'appendHeader' | 'setHeader'> {
+    req: HttpIncoming;
+    readonly finished?: boolean;
+    appendHeader(name: string, value: string | readonly string[]): this;
+    setHeader(name: string, value: number | string | readonly string[]): this;
     /**
      * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
      */
-    attachment(this: HttpServerResponse, filename?: string): this;
+    attachment(filename?: string): this;
     /** Clear cookie `name`. */
     clearCookie(name: string, options?: CookieOptions): this;
     /**
@@ -111,7 +112,7 @@ export interface HttpServerResponse extends HttpOutgoingMessage {
      * response to the standard description from node's http.STATUS_CODES
      * or the statusCode number if no description.
      */
-    sendStatus(statusCode: number): any;
+    sendStatus(statusCode: number): this;
     /**
      * Send a response.
      *
@@ -132,6 +133,12 @@ export interface CookieOptions {
     path?: string;
     domain?: string;
     secure?: boolean;
-    encode?: ((val: string) => string);
+    encode?: (val: string) => string;
     sameSite?: boolean | 'lax' | 'strict' | 'none';
 }
+/**
+ * @namespace HttpIncoming
+ */
+export declare namespace HttpOutgoing {
+    function from(instance: HttpOutgoing | NodeOutgoingMessage.Initiator): HttpOutgoing;
+}

package/types/http/interfaces/node-incoming-message.interface.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http from 'http';
+import { Readable } from 'stream';
+/**
+ * @interface NodeIncomingMessage
+ */
+export interface NodeIncomingMessage extends Readable, Pick<http.IncomingMessage, 'httpVersion' | 'httpVersionMajor' | 'httpVersionMinor' | 'complete' | 'headers' | 'trailers' | 'rawHeaders' | 'rawTrailers' | 'method' | 'url'> {
+}
+/**
+ *
+ * @namespace NodeIncomingMessage
+ */
+export declare namespace NodeIncomingMessage {
+    interface Initiator {
+        httpVersionMajor?: number;
+        httpVersionMinor?: number;
+        method?: string;
+        url?: string;
+        headers?: Record<string, any> | string[];
+        trailers?: Record<string, any> | string[];
+        params?: Record<string, any>;
+        cookies?: Record<string, any>;
+        body?: any;
+        ip?: string;
+        ips?: string[];
+    }
+    /**
+     * Creates a new NodeIncomingMessage from given argument
+     * @param iterable
+     */
+    function from(iterable: string | Iterable<any> | AsyncIterable<any> | Initiator): NodeIncomingMessage;
+    /**
+     * Creates a new NodeIncomingMessage from given argument
+     * @param iterable
+     */
+    function fromAsync(iterable: string | Iterable<any> | AsyncIterable<any> | Initiator): Promise<NodeIncomingMessage>;
+}

package/types/http/interfaces/node-outgoing-message.interface.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http, { OutgoingHttpHeaders } from 'http';
+import { Writable } from 'stream';
+import { NodeIncomingMessage } from './node-incoming-message.interface.js';
+export interface NodeOutgoingMessage extends Writable, Pick<http.ServerResponse, 'addTrailers' | 'getHeader' | 'getHeaders' | 'getHeaderNames' | 'flushHeaders' | 'removeHeader' | 'hasHeader' | 'headersSent' | 'statusCode' | 'statusMessage' | 'sendDate'> {
+    req: NodeIncomingMessage;
+    getRawHeaderNames(): string[];
+    appendHeader(name: string, value: string | readonly string[]): this;
+    setHeader(name: string, value: number | string | readonly string[]): this;
+}
+/**
+ *
+ * @namespace NodeOutgoingMessage
+ */
+export declare namespace NodeOutgoingMessage {
+    interface Initiator {
+        req: NodeIncomingMessage;
+        statusCode?: number;
+        statusMessage?: string;
+        headers?: OutgoingHttpHeaders | Headers | Map<string, any> | string[];
+        chunkedEncoding?: boolean;
+        sendDate?: boolean;
+        strictContentLength?: boolean;
+        body?: string | Iterable<any> | AsyncIterable<any> | Object;
+        parsedUrl?: URL;
+    }
+    function from(init: Initiator): NodeOutgoingMessage;
+}

package/types/http/utils/body-reader.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import nodeStream from 'node:stream';
+import type { HttpIncoming } from '../interfaces/http-incoming.interface.js';
+/**
+ *
+ * @namespace BodyReader
+ */
+export declare namespace BodyReader {
+    interface Options {
+        limit?: number | string;
+    }
+}
+type Callback = (...args: any[]) => any;
+/**
+ *
+ * @class BodyReader
+ */
+export declare class BodyReader extends EventEmitter {
+    readonly req: HttpIncoming;
+    limit?: number;
+    protected _stream: nodeStream.Readable;
+    protected _buffer?: string | Buffer[];
+    protected _completed?: boolean | undefined;
+    protected _receivedSize: number;
+    protected cleanup: Callback;
+    protected onAborted: Callback;
+    protected onData: Callback;
+    protected onEnd: Callback;
+    constructor(req: HttpIncoming, options?: BodyReader.Options);
+    read(): Promise<string | Buffer | undefined>;
+    protected _onEnd(error: any): void;
+    protected _cleanup(): void;
+    protected _onAborted(): void;
+    protected _onData(chunk: Buffer | string): void;
+    static read(req: HttpIncoming, options?: BodyReader.Options): Promise<string | Buffer | undefined>;
+    protected static encoderPipeline(req: HttpIncoming): nodeStream.Readable;
+}
+export {};

package/types/http/utils/wrap-exception.d.ts

@@ -0,0 +1,2 @@
+import { OpraHttpError } from '@opra/common';
+export declare function wrapException(error: any): OpraHttpError;

package/types/index.d.ts

@@ -1,30 +1,28 @@
-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 './type-guards.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/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/impl/multipart-reader.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 declare namespace classes {
+    export import HttpIncomingHost = HttpIncomingHost_.HttpIncomingHost;
+    export import HttpOutgoingHost = HttpOutgoingHost_.HttpOutgoingHost;
+    export import NodeIncomingMessageHost = NodeIncomingMessageHost_.NodeIncomingMessageHost;
+    export import NodeOutgoingMessageHost = NodeOutgoingMessageHost_.NodeOutgoingMessageHost;
+}

package/types/platform-adapter.d.ts

@@ -1,56 +1,28 @@
-import { ApiDocument, FallbackLng, I18n, LanguageResource } from '@opra/common';
-import { Interceptor } from './interfaces/interceptor.interface.js';
-import { ILogger } from './interfaces/logger.interface.js';
-import { RequestHandler } from './interfaces/request-handler.interface.js';
-import { RequestContext } from './request-context.js';
-export type Protocol = 'http' | 'ws' | 'rpc';
-export interface PlatformAdapter extends RequestHandler {
-    readonly api: ApiDocument;
-    readonly protocol: Protocol;
-    readonly platform: string;
-    readonly serviceName: string;
-    /**
-     * Calls shutDown hook for all resources
-     */
-    close(): Promise<void>;
-}
+import './augmentation/18n.augmentation.js';
+import { AsyncEventEmitter } from 'strict-typed-events';
+import { ApiDocument, I18n, OpraSchema } from '@opra/common';
+import { kAssetCache } from './constants.js';
+import { Logger } from './helpers/logger.js';
+import { AssetCache } from './http/impl/asset-cache.js';
+import type { ILogger } from './interfaces/logger.interface';
 /**
  * @namespace PlatformAdapter
  */
 export declare namespace PlatformAdapter {
     interface Options {
-        i18n?: I18n | I18nOptions | (() => Promise<I18n>);
+        i18n?: I18n;
         logger?: ILogger;
-        interceptors?: Interceptor[];
-        on?: {
-            request?: (ctx: RequestContext) => void | Promise<void>;
-        };
-    }
-    interface I18nOptions {
-        /**
-         * 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[];
     }
 }
+/**
+ * @class PlatformAdapter
+ */
+export declare abstract class PlatformAdapter extends AsyncEventEmitter {
+    protected [kAssetCache]: AssetCache;
+    readonly document: ApiDocument;
+    abstract readonly protocol: OpraSchema.Protocol;
+    logger: Logger;
+    i18n: I18n;
+    protected constructor(document: ApiDocument, options?: PlatformAdapter.Options);
+    abstract close(): Promise<void>;
+}

package/types/type-guards.d.ts

@@ -0,0 +1,8 @@
+import type { HttpIncoming } from './http/interfaces/http-incoming.interface.js';
+import type { HttpOutgoing } from './http/interfaces/http-outgoing.interface.js';
+import type { NodeIncomingMessage } from './http/interfaces/node-incoming-message.interface.js';
+import type { NodeOutgoingMessage } from './http/interfaces/node-outgoing-message.interface.js';
+export declare function isNodeIncomingMessage(v: any): v is NodeIncomingMessage;
+export declare function isHttpIncoming(v: any): v is HttpIncoming;
+export declare function isNodeOutgoingMessage(v: any): v is NodeOutgoingMessage;
+export declare function isHttpOutgoing(v: any): v is HttpOutgoing;

package/cjs/augmentation/collection.augmentation.js

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

package/cjs/augmentation/container.augmentation.js

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

package/cjs/augmentation/resource.augmentation.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@opra/common");
-// @ts-ignore
-const oldConstruct = common_1.Resource.prototype._construct;
-// @ts-ignore
-common_1.Resource.prototype._construct = function (init) {
-    oldConstruct.call(this, init);
-    const _this = this;
-    _this.onInit = init.onInit;
-    _this.onShutdown = init.onShutdown;
-};
-common_1.Collection.OnInit = common_1.Singleton.OnInit = function () {
-    return (target, propertyKey) => {
-        const sourceMetadata = (Reflect.getOwnMetadata(common_1.RESOURCE_METADATA, target.constructor) || {});
-        sourceMetadata.onInit = target[propertyKey];
-        Reflect.defineMetadata(common_1.RESOURCE_METADATA, target.constructor, sourceMetadata);
-    };
-};
-common_1.Collection.OnShutdown = common_1.Singleton.OnShutdown = function () {
-    return (target, propertyKey) => {
-        const sourceMetadata = (Reflect.getOwnMetadata(common_1.RESOURCE_METADATA, target.constructor) || {});
-        sourceMetadata.onShutdown = target[propertyKey];
-        Reflect.defineMetadata(common_1.RESOURCE_METADATA, target.constructor, sourceMetadata);
-    };
-};

package/cjs/augmentation/singleton.augmentation.js

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

package/cjs/augmentation/storage.augmentation.js

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

package/cjs/execution-context.host.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecutionContextHost = void 0;
-const strict_typed_events_1 = require("strict-typed-events");
-class ExecutionContextHost extends strict_typed_events_1.AsyncEventEmitter {
-    constructor(api, platform, protocol) {
-        super();
-        this.api = api;
-        this.platform = platform;
-        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');
-    }
-}
-exports.ExecutionContextHost = ExecutionContextHost;

package/cjs/http/adapters/express-adapter.host.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpressAdapterHost = void 0;
-const common_1 = require("@opra/common");
-const http_adapter_host_js_1 = require("../http-adapter-host.js");
-const http_server_request_js_1 = require("../http-server-request.js");
-const http_server_response_js_1 = require("../http-server-response.js");
-class ExpressAdapterHost extends http_adapter_host_js_1.HttpAdapterHost {
-    constructor(app) {
-        super();
-        this._platform = 'express';
-        this._app = app;
-    }
-    get app() {
-        return this._app;
-    }
-    async init(api, options) {
-        await super.init(api, options);
-        this._api = api;
-        const basePath = new common_1.OpraURLPath(options?.basePath);
-        this._app.use(basePath.toString(), (_req, _res) => {
-            const req = http_server_request_js_1.HttpServerRequest.from(_req);
-            const res = http_server_response_js_1.HttpServerResponse.from(_res);
-            this.handleHttp(req, res)
-                .catch((e) => this._logger.fatal(e));
-        });
-    }
-    static async create(app, api, options) {
-        const adapter = new ExpressAdapterHost(app);
-        await adapter.init(api, options);
-        return adapter;
-    }
-}
-exports.ExpressAdapterHost = ExpressAdapterHost;