@opra/core 1.0.0-beta.2 → 1.0.0-beta.4

package/esm/http/utils/match-known-fields.js

@@ -1,45 +0,0 @@
-import { HttpHeaderCodes } from '@opra/common';
-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 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(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,
-    ];
-    return o;
-}, {});
-export function matchKnownFields(field) {
-    const x = KNOWN_FIELDS[field.toLowerCase()];
-    return x ? x : [field, COMMA_DELIMITED_FIELD];
-}

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

@@ -1,30 +0,0 @@
-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/type-guards.js

@@ -1,16 +0,0 @@
-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/types/augmentation/http-controller.augmentation.d.ts

@@ -1,20 +0,0 @@
-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 {
-        type Context = HttpContext;
-    }
-}

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

@@ -1,10 +0,0 @@
-import type { 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

@@ -1,13 +0,0 @@
-import { ApiDocument, HttpController } from '@opra/common';
-import { type 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;
-}

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

@@ -1,54 +0,0 @@
-import { ApiDocument, HttpApi, OpraSchema } from '@opra/common';
-import { PlatformAdapter } from '../platform-adapter.js';
-import { HttpContext } from './http-context.js';
-import { HttpHandler } from './http-handler.js';
-export declare namespace HttpAdapter {
-    type NextCallback = () => Promise<void>;
-    /**
-     * @type InterceptorFunction
-     */
-    type InterceptorFunction = IHttpInterceptor['intercept'];
-    /**
-     * @interface IHttpInterceptor
-     */
-    type IHttpInterceptor = {
-        intercept(context: HttpContext, next: NextCallback): Promise<void>;
-    };
-    interface Options extends PlatformAdapter.Options {
-        basePath?: string;
-        interceptors?: (InterceptorFunction | IHttpInterceptor)[];
-    }
-    type EventFunction = (context: HttpContext) => void | Promise<void>;
-    interface Events {
-        createContext: EventFunction;
-        error: EventFunction;
-        request: EventFunction;
-    }
-}
-export interface HttpAdapter {
-    addListener<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
-    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-    on<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
-    on(event: string | symbol, listener: (...args: any[]) => void): this;
-    once<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
-    once(event: string | symbol, listener: (...args: any[]) => void): this;
-    removeListener<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
-    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-    off<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
-    off(event: string | symbol, listener: (...args: any[]) => void): this;
-    prependListener<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
-    prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-    prependOnceListener<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
-    prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
-}
-/**
- *
- * @class HttpAdapter
- */
-export declare abstract class HttpAdapter extends PlatformAdapter {
-    readonly handler: HttpHandler;
-    readonly protocol: OpraSchema.Protocol;
-    interceptors: (HttpAdapter.InterceptorFunction | HttpAdapter.IHttpInterceptor)[];
-    protected constructor(document: ApiDocument, options?: HttpAdapter.Options);
-    get api(): HttpApi;
-}

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

@@ -1,44 +0,0 @@
-import { HttpController, HttpMediaType, HttpOperation, OpraSchema } from '@opra/common';
-import { ExecutionContext } from '../execution-context.js';
-import type { HttpAdapter } from './http-adapter';
-import { MultipartReader } from './impl/multipart-reader.js';
-import type { HttpIncoming } from './interfaces/http-incoming.interface.js';
-import type { HttpOutgoing } from './interfaces/http-outgoing.interface.js';
-export declare namespace HttpContext {
-    interface Initiator extends Omit<ExecutionContext.Initiator, 'document' | 'protocol'> {
-        adapter: HttpAdapter;
-        request: HttpIncoming;
-        response: HttpOutgoing;
-        controller?: HttpController;
-        controllerInstance?: any;
-        operation?: HttpOperation;
-        operationHandler?: Function;
-        cookies?: Record<string, any>;
-        headers?: Record<string, any>;
-        pathParams?: Record<string, any>;
-        queryParams?: Record<string, any>;
-        mediaType?: HttpMediaType;
-        body?: any;
-    }
-}
-export declare class HttpContext extends ExecutionContext {
-    protected _body?: any;
-    protected _multipartReader?: MultipartReader;
-    readonly protocol: OpraSchema.Protocol;
-    readonly adapter: HttpAdapter;
-    readonly controller?: HttpController;
-    readonly controllerInstance?: any;
-    readonly operation?: HttpOperation;
-    readonly operationHandler?: Function;
-    readonly request: HttpIncoming;
-    readonly response: HttpOutgoing;
-    readonly mediaType?: HttpMediaType;
-    readonly cookies: Record<string, any>;
-    readonly headers: Record<string, any>;
-    readonly pathParams: Record<string, any>;
-    readonly queryParams: Record<string, any>;
-    constructor(init: HttpContext.Initiator);
-    get isMultipart(): boolean;
-    getMultipartReader(): Promise<MultipartReader>;
-    getBody<T>(): Promise<T>;
-}

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

@@ -1,75 +0,0 @@
-import { HttpOperationResponse, OpraException, OpraHttpError } from '@opra/common';
-import { kAssetCache } from '../constants.js';
-import type { HttpAdapter } from './http-adapter.js';
-import { HttpContext } from './http-context.js';
-import { AssetCache } from './impl/asset-cache.js';
-/**
- * @namespace
- */
-export declare namespace HttpHandler {
-    /**
-     * @interface ResponseArgs
-     */
-    interface ResponseArgs {
-        statusCode: number;
-        contentType?: string;
-        operationResponse?: HttpOperationResponse;
-        body?: any;
-        projection?: string[] | '*';
-    }
-}
-/**
- * @class HttpHandler
- */
-export declare class HttpHandler {
-    readonly adapter: HttpAdapter;
-    protected [kAssetCache]: AssetCache;
-    onError?: (context: HttpContext, error: OpraException) => void | Promise<void>;
-    constructor(adapter: HttpAdapter);
-    /**
-     * Main http request handler
-     * @param context
-     * @protected
-     */
-    handleRequest(context: HttpContext): Promise<void>;
-    /**
-     *
-     * @param context
-     */
-    parseRequest(context: HttpContext): Promise<void>;
-    /**
-     *
-     * @param context
-     * @protected
-     */
-    protected _parseParameters(context: HttpContext): Promise<void>;
-    /**
-     *
-     * @param context
-     * @protected
-     */
-    protected _parseContentType(context: HttpContext): Promise<void>;
-    /**
-     *
-     * @param context
-     * @protected
-     */
-    protected _executeRequest(context: HttpContext): Promise<any>;
-    /**
-     *
-     * @param context
-     * @param responseValue
-     * @protected
-     */
-    sendResponse(context: HttpContext, responseValue?: any): Promise<void>;
-    protected _sendErrorResponse(context: HttpContext): Promise<void>;
-    sendDocumentSchema(context: HttpContext): Promise<void>;
-    /**
-     *
-     * @param context
-     * @param body
-     * @protected
-     */
-    protected _determineResponseArgs(context: HttpContext, body: any): HttpHandler.ResponseArgs;
-    protected _wrapExceptions(exceptions: any[]): OpraHttpError[];
-}

package/types/http/impl/http-incoming.host.d.ts

@@ -1,22 +0,0 @@
-import parseRange from 'range-parser';
-import type { HttpIncoming } from '../interfaces/http-incoming.interface.js';
-import { BodyReader } from '../utils/body-reader.js';
-export interface HttpIncomingHost extends HttpIncoming {
-}
-export declare class HttpIncomingHost implements HttpIncoming {
-    body?: any;
-    get protocol(): string;
-    get secure(): boolean;
-    get hostname(): string | undefined;
-    get fresh(): boolean;
-    get xhr(): boolean;
-    header(name: string): any;
-    get(name: string): any;
-    accepts(...types: any): any;
-    acceptsCharsets(...charsets: any): any;
-    acceptsEncodings(...encoding: any): any;
-    acceptsLanguages(...lang: any): any;
-    is(type: string | string[], ...otherTypes: string[]): string | false | null;
-    range(size: number, options: any): parseRange.Ranges | parseRange.Result | undefined;
-    readBody(options: BodyReader.Options): Promise<string | Buffer | undefined>;
-}

package/types/http/impl/http-outgoing.host.d.ts

@@ -1,17 +0,0 @@
-import type { CookieOptions, HttpOutgoing } from '../interfaces/http-outgoing.interface.js';
-export interface HttpOutgoingHost extends HttpOutgoing {
-}
-export declare class HttpOutgoingHost {
-    attachment(filename?: string): this;
-    contentType(type: any): this;
-    setHeader(field: string | Record<string, any>, val?: any): this;
-    clearCookie(name: string, options: CookieOptions): this;
-    cookie(name: string, value: any, options?: CookieOptions): this;
-    status(code: number): this;
-    sendStatus(statusCode: number): this;
-    links(links: Record<string, string>): this;
-    location(url: string): this;
-    redirect(arg0: string | number, arg1?: string): void;
-    send(body: any): this;
-    vary(field: string): this;
-}

package/types/http/impl/multipart-reader.d.ts

@@ -1,46 +0,0 @@
-import { HttpMediaType } from '@opra/common';
-import busboy from 'busboy';
-import { EventEmitter } from 'events';
-import type { StrictOmit } from 'ts-gems';
-import { HttpContext } from '../http-context.js';
-export declare namespace MultipartReader {
-    interface Options extends StrictOmit<busboy.BusboyConfig, 'headers'> {
-        tempDirectory?: string;
-    }
-    interface FieldInfo {
-        kind: 'field';
-        field: string;
-        value?: any;
-        mimeType?: string;
-        encoding?: string;
-    }
-    interface FileInfo {
-        kind: 'file';
-        field: string;
-        filename: string;
-        storedPath: string;
-        mimeType?: string;
-        encoding?: string;
-    }
-    type Item = FieldInfo | FileInfo;
-}
-export declare class MultipartReader extends EventEmitter {
-    protected context: HttpContext;
-    protected mediaType?: HttpMediaType | undefined;
-    protected _started: boolean;
-    protected _finished: boolean;
-    protected _cancelled: boolean;
-    protected _form: busboy.Busboy;
-    protected _items: MultipartReader.Item[];
-    protected _stack: MultipartReader.Item[];
-    protected tempDirectory: string;
-    constructor(context: HttpContext, options?: MultipartReader.Options, mediaType?: HttpMediaType | undefined);
-    get items(): MultipartReader.Item[];
-    getNext(): Promise<MultipartReader.Item | undefined>;
-    getAll(): Promise<MultipartReader.Item[]>;
-    getAll_(): Promise<MultipartReader.Item[]>;
-    cancel(): void;
-    resume(): void;
-    pause(): void;
-    purge(): Promise<PromiseSettledResult<any>[]>;
-}

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

@@ -1,45 +0,0 @@
-import { type HTTPParserJS } from '@browsery/http-parser';
-import type { IncomingHttpHeaders } from 'http';
-import { Duplex, Readable } from 'stream';
-import type { NodeIncomingMessage } from '../interfaces/node-incoming-message.interface.js';
-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 declare const kHttpParser: unique symbol;
-/**
- *
- * @class NodeIncomingMessageHost
- */
-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 [kHttpParser]: HTTPParserJS | undefined;
-    protected _readStream?: Readable;
-    httpVersionMajor: number;
-    httpVersionMinor: number;
-    method: string;
-    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?: NodeIncomingMessage.Initiator);
-    get httpVersion(): string;
-    get headers(): IncomingHttpHeaders;
-    set headers(headers: IncomingHttpHeaders);
-    get headersDistinct(): NodeJS.Dict<string[]>;
-    get trailers(): NodeJS.Dict<string>;
-    set trailers(trailers: NodeJS.Dict<string>);
-    get trailersDistinct(): NodeJS.Dict<string[]>;
-    _read(size: number): void;
-    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-}

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

@@ -1,49 +0,0 @@
-import type { OutgoingHttpHeaders } from 'http';
-import { Duplex } from 'stream';
-import type { NodeIncomingMessage } from '../interfaces/node-incoming-message.interface.js';
-import type { NodeOutgoingMessage } from '../interfaces/node-outgoing-message.interface.js';
-export declare const kOutHeaders: unique symbol;
-export declare const kOutTrailers: unique symbol;
-declare global {
-    interface Headers {
-        keys(): IterableIterator<string>;
-        entries(): IterableIterator<[string, any]>;
-    }
-}
-/**
- *
- * @class NodeOutgoingMessageHost
- */
-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: NodeIncomingMessage;
-    statusCode: number;
-    statusMessage: string;
-    chunkedEncoding: boolean;
-    sendDate: boolean;
-    strictContentLength: boolean;
-    body?: any;
-    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;
-    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(): 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;
-}