@opra/core 0.22.0 → 0.23.0

package/esm/adapter/services/logger.js

@@ -0,0 +1,32 @@
+export 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);
+    }
+}

package/esm/augmentation/collection.augmentation.js

@@ -0,0 +1 @@
+export {};

package/esm/augmentation/singleton.augmentation.js

@@ -0,0 +1 @@
+export {};

package/esm/augmentation/storage.augmentation.js

@@ -0,0 +1 @@
+export {};

package/esm/index.js

@@ -1,15 +1,21 @@
 import "reflect-metadata";
 import './augmentation/resource.augmentation.js';
+import './augmentation/collection.augmentation.js';
+import './augmentation/singleton.augmentation.js';
+import './augmentation/storage.augmentation.js';
 export * from './types.js';
-export * from './adapter/adapter.js';
+export * from './adapter/execution-context.js';
+export * from './adapter/operation-context.js';
+export * from './adapter/platform-adapter.js';
+export * from './adapter/request.js';
+export * from './adapter/response.js';
 export * from './adapter/http/express-adapter.js';
 export * from './adapter/http/http-adapter.js';
-export * from './adapter/http/impl/http-server-request.js';
-export * from './adapter/http/impl/http-server-response.js';
-export * from './adapter/http/impl/http-incoming-message-host.js';
-export * from './adapter/http/impl/http-outgoing-message-host.js';
-export * from './adapter/interfaces/request-context.interface.js';
+export * from './adapter/http/impl/http-incoming-message.host.js';
+export * from './adapter/http/impl/http-outgoing-message.host.js';
+export * from './adapter/http/http-server-request.js';
+export * from './adapter/http/http-server-response.js';
 export * from './adapter/interfaces/logger.interface.js';
-export * from './adapter/interfaces/request.interface.js';
-export * from './adapter/interfaces/response.interface.js';
-export * from './shared/collection-resource-base.js';
+export * from './adapter/interfaces/request-handler.interface.js';
+export * from './adapter/services/logger.js';
+export * from './adapter/http/helpers/multipart-helper.js';

package/i18n/en/error.json

@@ -10,6 +10,9 @@
   "UNPROCESSABLE_ENTITY": "Unprocessable entity",
   "RESOURCE_NOT_FOUND": "Resource not found: '{{resource}}'",
   "RESOURCE_CONFLICT": "There is already an other {{resource}} resource with same field values ({{fields}})",
-  "RESOLVER_FORBIDDEN": "The resource endpoint does not accept '{{operation}}' operations",
-  "UNACCEPTED_SORT_FIELD": "Field '{{field}}' is not available for sort operation"
+  "RESOLVER_FORBIDDEN": "The {{resource}} endpoint does not accept '{{operation}}' operations",
+  "UNKNOWN_FIELD": "Unknown field '{{field}}'",
+  "UNACCEPTED_SORT_FIELD": "Field '{{field}}' is not available for sort operation",
+  "UNACCEPTED_FILTER_FIELD": "Field '{{field}}' is not available for filter operation",
+  "UNACCEPTED_FILTER_OPERATION": "'{{operation}}' for field '{{field}}' is not available for filter operation"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -27,7 +27,7 @@
     "clean:cover": "rimraf ../../coverage/core"
   },
   "dependencies": {
-    "@opra/common": "^0.22.0",
+    "@opra/common": "^0.23.0",
     "accepts": "^1.3.8",
     "content-disposition": "^0.5.4",
     "content-type": "^1.0.5",
@@ -39,6 +39,7 @@
     "mime-types": "^2.1.35",
     "power-tasks": "^1.7.0",
     "putil-varhelpers": "^1.6.5",
+    "putil-isplainobject": "^1.1.5",
     "range-parser": "^1.2.1",
     "strict-typed-events": "^2.3.1",
     "type-is": "^1.6.18",

package/types/adapter/execution-context.d.ts

@@ -0,0 +1,31 @@
+import type { HttpServerRequest } from './http/http-server-request';
+import type { HttpServerResponse } from './http/http-server-response';
+import type { Protocol } from './platform-adapter';
+export declare namespace ExecutionContext {
+    type OnFinishArgs = {
+        context: ExecutionContext;
+        failed: boolean;
+    };
+}
+export interface ExecutionContext {
+    readonly protocol: Protocol;
+    readonly platform: string;
+    errors: Error[];
+    executionScope: Record<string | number | symbol, any>;
+    switchToHttp(): HttpMessageContext;
+    switchToWs(): WsMessageContext;
+    switchToRpc(): RpcMessageContext;
+    on(event: 'finish', fn: (args: ExecutionContext.OnFinishArgs) => void | Promise<void>): any;
+}
+export interface HttpMessageContext {
+    readonly platform: string;
+    readonly incoming: HttpServerRequest;
+    readonly outgoing: HttpServerResponse;
+    switchToContext(): ExecutionContext;
+}
+export interface WsMessageContext {
+    switchToContext(): ExecutionContext;
+}
+export interface RpcMessageContext {
+    switchToContext(): ExecutionContext;
+}

package/types/adapter/execution-context.host.d.ts

@@ -0,0 +1,27 @@
+import { AsyncEventEmitter } from 'strict-typed-events';
+import type { ApiDocument } from '@opra/common';
+import type { HttpServerResponse } from './/http/http-server-response.js';
+import type { ExecutionContext, HttpMessageContext, RpcMessageContext, WsMessageContext } from './execution-context.js';
+import type { HttpServerRequest } from './http/http-server-request.js';
+import { Protocol } from './platform-adapter.js';
+export declare class ExecutionContextHost extends AsyncEventEmitter implements ExecutionContext {
+    readonly api: ApiDocument;
+    readonly platform: string;
+    readonly protocol: Protocol;
+    readonly http?: HttpMessageContext;
+    readonly ws?: WsMessageContext;
+    readonly rpc?: RpcMessageContext;
+    errors: Error[];
+    executionScope: Record<string | number | symbol, any>;
+    constructor(api: ApiDocument, platform: string, protocol: {
+        http?: {
+            incoming: HttpServerRequest;
+            outgoing: HttpServerResponse;
+        };
+        ws?: WsMessageContext;
+        rpc?: RpcMessageContext;
+    });
+    switchToHttp(): HttpMessageContext;
+    switchToWs(): WsMessageContext;
+    switchToRpc(): RpcMessageContext;
+}

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

@@ -1,11 +1,15 @@
 import type { Application } from 'express';
-import { ApiDocument } from '@opra/common';
-import { OpraHttpAdapter } from './http-adapter.js';
-export declare namespace OpraExpressAdapter {
-    interface Options extends OpraHttpAdapter.Options {
-    }
+import type { ApiDocument } from '@opra/common';
+import type { PlatformAdapter } from '../platform-adapter.js';
+import type { HttpAdapter } from './http-adapter.js';
+export interface ExpressAdapter extends PlatformAdapter {
+    readonly app: Application;
 }
-export declare class OpraExpressAdapter extends OpraHttpAdapter {
-    protected platform: string;
-    static create(app: Application, document: ApiDocument, options?: OpraExpressAdapter.Options): Promise<OpraExpressAdapter>;
+/**
+ * @namespace
+ */
+export declare namespace ExpressAdapter {
+    interface Options extends HttpAdapter.Options {
+    }
+    function create(app: Application, api: ApiDocument, options?: ExpressAdapter.Options): Promise<ExpressAdapter>;
 }

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

@@ -0,0 +1,11 @@
+import type { Application } from 'express';
+import { ApiDocument } from '@opra/common';
+import type { ExpressAdapter } from './express-adapter';
+import { HttpAdapterBase } from './http-adapter-base.js';
+export declare class ExpressAdapterHost extends HttpAdapterBase implements ExpressAdapter {
+    _platform: string;
+    _options: ExpressAdapter.Options;
+    _app: Application;
+    constructor(app: Application, api: ApiDocument, options?: ExpressAdapter.Options);
+    get app(): Application;
+}

package/types/adapter/http/helpers/concat-readable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+export declare function concatReadable(...streams: Readable[]): Readable;

package/types/adapter/http/helpers/multipart-helper.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import formidable from 'formidable';
+import type IncomingForm from 'formidable/Formidable.js';
+import { HttpIncomingMessage } from '../impl/http-incoming-message.host.js';
+export type MultipartFile = formidable.File;
+export type MultipartItem = {
+    field: string;
+    value?: string;
+    file?: MultipartFile;
+};
+export declare class MultipartIterator extends EventEmitter {
+    protected _cancelled: boolean;
+    protected _form: IncomingForm;
+    protected _items: MultipartItem[];
+    protected _stack: MultipartItem[];
+    constructor(incoming: HttpIncomingMessage, options?: formidable.Options);
+    get items(): MultipartItem[];
+    getNext(): Promise<MultipartItem | undefined>;
+    getAll(): Promise<MultipartItem[]>;
+    cancel(): void;
+    resume(): void;
+    pause(): void;
+    deleteFiles(): Promise<PromiseSettledResult<any>[]>;
+}

package/types/adapter/http/helpers/query-parsers.d.ts

@@ -0,0 +1 @@
+export declare function parseArrayParam(v?: string | null): string[] | undefined;

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

@@ -0,0 +1,23 @@
+import { ExecutionContext } from '../execution-context.js';
+import { RequestHandler } from '../interfaces/request-handler.interface.js';
+import type { Protocol } from '../platform-adapter';
+import { PlatformAdapterHost } from '../platform-adapter.host.js';
+import { HttpServerRequest } from './http-server-request.js';
+import { HttpServerResponse } from './http-server-response.js';
+/**
+ *
+ * @class HttpAdapterBase
+ */
+export declare abstract class HttpAdapterBase extends PlatformAdapterHost {
+    _protocol: Protocol;
+    _requestHandlers: RequestHandler[];
+    /**
+     * Main http request handler
+     * @param incoming
+     * @param outgoing
+     * @protected
+     */
+    protected handleIncoming(incoming: HttpServerRequest, outgoing: HttpServerResponse): Promise<void>;
+    processRequest(context: ExecutionContext): Promise<void>;
+    protected handleError(context: ExecutionContext): Promise<void>;
+}

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

@@ -1,33 +1,17 @@
-import { Task } from 'power-tasks';
-import { OpraAdapter } from '../adapter.js';
-import { ILogger } from '../interfaces/logger.interface.js';
-import { Request } from '../interfaces/request.interface.js';
-import { RequestContext } from '../interfaces/request-context.interface.js';
-import { HttpServerRequest } from './impl/http-server-request.js';
-import { HttpServerResponse } from './impl/http-server-response.js';
-/**
- * @namespace OpraHttpAdapter
- */
-export declare namespace OpraHttpAdapter {
-    type Options = OpraAdapter.Options & {
-        prefix?: string;
-    };
+/// <reference types="node" />
+import http from 'http';
+import type { ApiDocument, OpraURLPath } from '@opra/common';
+import type { PlatformAdapter } from '../platform-adapter';
+export interface HttpAdapter extends PlatformAdapter {
+    readonly basePath: OpraURLPath;
+    readonly server: http.Server;
 }
 /**
- *
- * @class OpraHttpAdapter
+ * @namespace HttpAdapter
  */
-export declare abstract class OpraHttpAdapter extends OpraAdapter {
-    protected abstract platform: string;
-    /**
-     * Main http request handler
-     * @param incoming
-     * @param outgoing
-     * @protected
-     */
-    protected handler(incoming: HttpServerRequest, outgoing: HttpServerResponse): Promise<void>;
-    protected createRequestTask(request: Request, outgoing: HttpServerResponse): Task;
-    protected executeRequest(context: RequestContext): Promise<void>;
-    protected handleError(incoming: HttpServerRequest, outgoing: HttpServerResponse, errors: any[]): Promise<void>;
-    protected log(logType: keyof ILogger, incoming: HttpServerRequest, message: string, ...optionalParams: any[]): void;
+export declare namespace HttpAdapter {
+    type Options = PlatformAdapter.Options & {
+        basePath?: string;
+    };
+    function create(api: ApiDocument, options?: Options): Promise<HttpAdapter>;
 }

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import http from 'http';
+import { ApiDocument, OpraURLPath } from '@opra/common';
+import type { HttpAdapter } from './http-adapter';
+import { HttpAdapterBase } from './http-adapter-base.js';
+/**
+ * @class HttpAdapterHost
+ */
+export declare class HttpAdapterHost extends HttpAdapterBase implements HttpAdapter {
+    _basePath: OpraURLPath;
+    _options: HttpAdapter.Options;
+    _server: http.Server;
+    constructor(api: ApiDocument, options?: HttpAdapter.Options);
+    get basePath(): OpraURLPath;
+    get server(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    protected _serverListener(incomingMessage: http.IncomingMessage, serverResponse: http.ServerResponse): void;
+    close(): Promise<void>;
+}

package/types/adapter/http/{impl/http-server-request.d.ts → http-server-request.d.ts}

@@ -1,14 +1,15 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { Options as RangeParserOptions, Ranges as RangeParserRanges, Result as RangeParserResult } from 'range-parser';
-import stream from 'stream';
-import { HttpIncomingMessage, HttpIncomingMessageHost } from './http-incoming-message-host.js';
-import type { HttpServerResponse } from './http-server-response.js';
+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 create(instance?: HttpIncomingMessage | HttpIncomingMessageHost.Initiator | Buffer | stream.Readable): HttpServerRequest;
+    function from(instance: HttpIncomingMessage | HttpIncomingMessageHost.Initiator | string | Iterable<any> | AsyncIterable<any>): HttpServerRequest;
 }
 export interface HttpServerRequest extends HttpIncomingMessage {
     res: HttpServerResponse;
+    baseUrl: string;
+    originalUrl: string;
+    parsedUrl: OpraURL;
     body?: any;
     /**
      * Return the protocol string "http" or "https"

package/types/adapter/http/{impl/http-server-response.d.ts → http-server-response.d.ts}

@@ -1,7 +1,7 @@
-import { HttpOutgoingMessage, HttpOutgoingMessageHost } from './http-outgoing-message-host.js';
 import type { HttpServerRequest } from './http-server-request.js';
+import { HttpOutgoingMessage, HttpOutgoingMessageHost } from './impl/http-outgoing-message.host.js';
 export declare namespace HttpServerResponse {
-    function create(instance?: HttpOutgoingMessage | HttpOutgoingMessageHost.Initiator): HttpServerResponse;
+    function from(instance?: HttpOutgoingMessage | HttpOutgoingMessageHost.Initiator): HttpServerResponse;
 }
 export interface HttpServerResponse extends HttpOutgoingMessage {
     req?: HttpServerRequest;

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

@@ -3,14 +3,14 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import http, { IncomingHttpHeaders } from 'http';
-import * as stream from 'stream';
-import { Readable } from 'stream';
+import { Duplex, Readable } from 'stream';
+import { HTTPParserJS } from '@browsery/http-parser';
 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'>, stream.Readable {
+export interface HttpIncomingMessage extends Pick<http.IncomingMessage, 'httpVersion' | 'httpVersionMajor' | 'httpVersionMinor' | 'complete' | 'headers' | 'trailers' | 'rawHeaders' | 'rawTrailers' | 'method' | 'url'>, Readable {
 }
 export declare namespace HttpIncomingMessageHost {
     interface Initiator {
@@ -25,25 +25,29 @@ export declare namespace HttpIncomingMessageHost {
         ips?: string[];
     }
 }
-export interface HttpIncomingMessageHost extends stream.Readable {
-}
 /**
  *
  * @class HttpIncomingMessageHost
  */
-export declare class HttpIncomingMessageHost implements HttpIncomingMessage {
+export declare class HttpIncomingMessageHost extends Duplex implements HttpIncomingMessage {
+    protected [kHeaders]?: IncomingHttpHeaders;
+    protected [kHeadersDistinct]?: NodeJS.Dict<string[]>;
+    protected [kTrailers]?: NodeJS.Dict<string>;
+    protected [kTrailersDistinct]?: NodeJS.Dict<string[]>;
+    protected _httpParser: HTTPParserJS | undefined;
+    protected _readStream?: Readable;
     httpVersionMajor: number;
     httpVersionMinor: number;
     method: string;
     url: string;
     rawHeaders: string[];
     rawTrailers: string[];
-    body?: any;
+    body?: Buffer;
     complete: boolean;
     ip?: string;
     ips?: string[];
     joinDuplicateHeaders: boolean;
-    constructor();
+    constructor(init?: HttpIncomingMessageHost.Initiator);
     get httpVersion(): string;
     get headers(): IncomingHttpHeaders;
     set headers(headers: IncomingHttpHeaders);
@@ -51,8 +55,8 @@ export declare class HttpIncomingMessageHost implements HttpIncomingMessage {
     get trailers(): NodeJS.Dict<string>;
     set trailers(trailers: NodeJS.Dict<string>);
     get trailersDistinct(): NodeJS.Dict<string[]>;
-    protected _readConfig(init: HttpIncomingMessageHost.Initiator): void;
-    protected _readBuffer(buf: Buffer | ArrayBuffer): void;
-    _readStream(readable: Readable): void;
-    static create(init?: HttpIncomingMessageHost.Initiator | Buffer | stream.Readable): HttpIncomingMessageHost;
+    _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/adapter/http/impl/{http-outgoing-message-host.d.ts → http-outgoing-message.host.d.ts}

@@ -2,18 +2,17 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import http, { OutgoingHttpHeaders } from 'http';
-import * as stream from 'stream';
-import type { HttpIncomingMessage } from './http-incoming-message-host.js';
+import { Duplex, Writable } from 'stream';
+import type { HttpIncomingMessage } from './http-incoming-message.host';
 export declare const kOutHeaders: unique symbol;
 export declare const kOutTrailers: unique symbol;
-export declare const kErrored: unique symbol;
 declare global {
     interface Headers {
         keys(): IterableIterator<string>;
         entries(): IterableIterator<[string, any]>;
     }
 }
-export interface HttpOutgoingMessage extends Pick<http.ServerResponse, 'addTrailers' | 'getHeader' | 'getHeaders' | 'getHeaderNames' | 'removeHeader' | 'hasHeader' | 'headersSent' | 'statusCode' | 'statusMessage' | 'sendDate'>, stream.Writable {
+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;
@@ -27,21 +26,19 @@ export declare namespace HttpOutgoingMessageHost {
         chunkedEncoding?: boolean;
         sendDate?: boolean;
         strictContentLength?: boolean;
-        body?: any;
+        body?: string | Iterable<any> | AsyncIterable<any> | Object;
     }
 }
-export interface HttpOutgoingMessageHost extends stream.Writable {
-}
 /**
  *
  * @class HttpOutgoingMessageHost
  */
-export declare class HttpOutgoingMessageHost {
-    protected _headersSent: boolean;
-    protected _closed: boolean;
-    protected [kErrored]: Error | null;
+export declare class HttpOutgoingMessageHost extends Duplex implements HttpOutgoingMessage {
     protected [kOutHeaders]: Record<string, any>;
     protected [kOutTrailers]: Record<string, any>;
+    protected _headersSent: boolean;
+    protected _httpVersionMajor?: number;
+    protected _httpVersionMinor?: number;
     finished: boolean;
     req?: HttpIncomingMessage;
     statusCode: number;
@@ -50,10 +47,10 @@ export declare class HttpOutgoingMessageHost {
     sendDate: boolean;
     strictContentLength: boolean;
     body?: any;
-    constructor();
+    constructor(init?: HttpOutgoingMessageHost.Initiator);
+    get httpVersionMajor(): number | undefined;
+    get httpVersionMinor(): number | undefined;
     get headersSent(): boolean;
-    get closed(): boolean;
-    get errored(): Error | null;
     appendHeader(name: string, value: number | string | readonly string[]): this;
     addTrailers(headers: OutgoingHttpHeaders | [string, string][] | readonly [string, string][]): void;
     setHeader(name: any, value: any): this;
@@ -67,6 +64,5 @@ export declare class HttpOutgoingMessageHost {
     end(cb?: () => void): this;
     end(chunk: any, cb?: () => void): this;
     end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
-    protected _readConfig(init: HttpOutgoingMessageHost.Initiator): void;
-    static create(init?: HttpOutgoingMessageHost.Initiator): HttpOutgoingMessageHost;
+    static from(init: HttpOutgoingMessageHost.Initiator): HttpOutgoingMessageHost;
 }

package/types/adapter/http/request-handlers/entity-request-handler.d.ts

@@ -0,0 +1,24 @@
+import { Collection, OpraSchema, Singleton } from '@opra/common';
+import { ExecutionContext } from '../../execution-context.js';
+import { OperationContext } from '../../operation-context.js';
+import { Request } from '../../request.js';
+import type { HttpAdapterBase } from '../http-adapter-base.js';
+import { HttpServerRequest } from '../http-server-request.js';
+import { RequestHandlerBase } from './request-handler-base.js';
+type BodyLoaderFunction = (incoming: HttpServerRequest) => Promise<any>;
+/**
+ * @class EntityRequestHandler
+ */
+export declare class EntityRequestHandler extends RequestHandlerBase {
+    readonly adapter: HttpAdapterBase;
+    readonly bodyLoaders: WeakMap<Object, BodyLoaderFunction>;
+    constructor(adapter: HttpAdapterBase);
+    processRequest(executionContext: ExecutionContext): Promise<void>;
+    parseRequest(incoming: HttpServerRequest): Promise<Request | undefined>;
+    executeOperation(context: OperationContext): Promise<void>;
+    sendResponse(context: OperationContext): Promise<void>;
+    parseCollectionRequest(resource: Collection, incoming: HttpServerRequest): Promise<Request>;
+    parseSingletonRequest(resource: Singleton, incoming: HttpServerRequest): Promise<Request>;
+    getBodyLoader(operation: OpraSchema.Collection.CreateOperation | OpraSchema.Collection.UpdateOperation | OpraSchema.Collection.UpdateManyOperation): BodyLoaderFunction;
+}
+export {};

package/types/adapter/http/request-handlers/request-handler-base.d.ts

@@ -0,0 +1,15 @@
+import { OpraSchema, Resource } from '@opra/common';
+import type { ExecutionContext } from '../../execution-context';
+import type { RequestHandler } from '../../interfaces/request-handler.interface';
+import type { HttpAdapterBase } from '../http-adapter-base';
+/**
+ * @class RequestHandlerBase
+ */
+export declare abstract class RequestHandlerBase implements RequestHandler {
+    readonly adapter: HttpAdapterBase;
+    protected constructor(adapter: HttpAdapterBase);
+    abstract processRequest(executionContext: ExecutionContext): Promise<void>;
+    assertOperation<T extends OpraSchema.Operation = OpraSchema.Operation>(resource: Resource, operation: string): Promise<T & {
+        controller: any;
+    }>;
+}

package/types/adapter/http/request-handlers/storage-request-handler.d.ts

@@ -0,0 +1,23 @@
+import type { ExecutionContext } from '../../execution-context';
+import { OperationContext } from '../../operation-context.js';
+import { Request } from '../../request.js';
+import type { HttpAdapterBase } from '../http-adapter-base.js';
+import { HttpServerRequest } from '../http-server-request.js';
+import { RequestHandlerBase } from './request-handler-base.js';
+export declare namespace StorageRequestHandler {
+    interface Options {
+        uploadDir?: string;
+    }
+}
+/**
+ * @class StorageRequestHandler
+ */
+export declare class StorageRequestHandler extends RequestHandlerBase {
+    readonly adapter: HttpAdapterBase;
+    _uploadDir: string;
+    constructor(adapter: HttpAdapterBase, options?: StorageRequestHandler.Options);
+    processRequest(executionContext: ExecutionContext): Promise<void>;
+    parseRequest(executionContext: ExecutionContext, incoming: HttpServerRequest): Promise<Request | undefined>;
+    executeOperation(context: OperationContext): Promise<void>;
+    sendResponse(context: OperationContext): Promise<void>;
+}

package/types/adapter/interfaces/logger.interface.d.ts

@@ -1,8 +1,9 @@
 export interface ILogger {
-    log(message: any, ...optionalParams: any[]): any;
-    error(message: any, ...optionalParams: any[]): any;
-    fatal?(message: any, ...optionalParams: any[]): any;
-    warn(message: any, ...optionalParams: any[]): any;
-    debug?(message: any, ...optionalParams: any[]): any;
-    verbose?(message: any, ...optionalParams: any[]): any;
+    log?(message: any, ...optionalParams: any[]): void;
+    info?(message: any, ...optionalParams: any[]): void;
+    warn?(message: any, ...optionalParams: any[]): void;
+    error?(message: any, ...optionalParams: any[]): void;
+    fatal?(message: any, ...optionalParams: any[]): void;
+    debug?(message: any, ...optionalParams: any[]): void;
+    verbose?(message: any, ...optionalParams: any[]): void;
 }

package/types/adapter/interfaces/request-handler.interface.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutionContext } from '../execution-context.js';
+export interface RequestHandler {
+    processRequest(executionContext: ExecutionContext): Promise<void>;
+}

package/types/adapter/operation-context.d.ts

@@ -0,0 +1,11 @@
+import type { ExecutionContext } from './execution-context';
+import type { Request } from './request';
+import type { Response } from './response';
+export interface OperationContext<TRequest extends Request = Request, TResponse extends Response = Response> extends ExecutionContext {
+    request: TRequest;
+    response: TResponse;
+    requestScope: Record<string | number | symbol, any>;
+}
+export declare namespace OperationContext {
+    function from<TRequest extends Request = Request, TResponse extends Response = Response>(executionContext: ExecutionContext, request: TRequest, response: TResponse): OperationContext;
+}