@opra/core 0.22.0 → 0.23.0

package/esm/adapter/http/impl/http-incoming-message-host.js

@@ -1,122 +0,0 @@
-/*
-  This file contains code blocks from open source NodeJs project
-  https://github.com/nodejs/
- */
-import * as stream from 'stream';
-import { HTTPParser } from '@browsery/http-parser';
-import { isReadable } from '@opra/common';
-import { convertToHeaders, convertToHeadersDistinct } from '../helpers/convert-to-headers.js';
-import { convertToRawHeaders } from '../helpers/convert-to-raw-headers.js';
-export const CRLF = Buffer.from('\r\n');
-export const kHeaders = Symbol('kHeaders');
-export const kHeadersDistinct = Symbol('kHeadersDistinct');
-export const kTrailers = Symbol('kTrailers');
-export const kTrailersDistinct = Symbol('kTrailersDistinct');
-/**
- *
- * @class HttpIncomingMessageHost
- */
-export class HttpIncomingMessageHost {
-    constructor() {
-        this.rawHeaders = [];
-        this.rawTrailers = [];
-        this.complete = false;
-        this.joinDuplicateHeaders = false;
-        stream.Readable.apply(this);
-    }
-    get httpVersion() {
-        return this.httpVersionMajor
-            ? this.httpVersionMajor + '.' + this.httpVersionMinor
-            : '';
-    }
-    get headers() {
-        if (!this[kHeaders])
-            this[kHeaders] = convertToHeaders(this.rawHeaders, {}, this.joinDuplicateHeaders);
-        return this[kHeaders];
-    }
-    set headers(headers) {
-        this[kHeaders] = headers;
-    }
-    get headersDistinct() {
-        if (!this[kHeadersDistinct])
-            this[kHeadersDistinct] = convertToHeadersDistinct(this.rawHeaders, {});
-        return this[kHeadersDistinct];
-    }
-    get trailers() {
-        if (!this[kTrailers])
-            this[kTrailers] = convertToHeaders(this.rawTrailers, {}, this.joinDuplicateHeaders);
-        return this[kTrailers];
-    }
-    set trailers(trailers) {
-        this[kTrailers] = trailers;
-    }
-    get trailersDistinct() {
-        if (!this[kTrailersDistinct])
-            this[kTrailersDistinct] = convertToHeadersDistinct(this.rawTrailers, {});
-        return this[kTrailersDistinct];
-    }
-    _readConfig(init) {
-        this.complete = true;
-        this.httpVersionMajor = init?.httpVersionMajor || 1;
-        this.httpVersionMinor = init?.httpVersionMinor || 0;
-        this.method = (init.method || 'GET').toUpperCase();
-        this.url = init.url || '';
-        this.body = init.body;
-        if (init.headers)
-            this.rawHeaders = Array.isArray(init.headers) ? init.headers : convertToRawHeaders(init.headers);
-        if (init.trailers)
-            this.rawTrailers = Array.isArray(init.trailers) ? init.trailers : convertToRawHeaders(init.trailers);
-        this.ip = init.ip || '';
-        this.ips = init.ips || (this.ip ? [this.ip] : []);
-    }
-    _readBuffer(buf) {
-        const parser = new HTTPParser(HTTPParser.REQUEST);
-        let bodyChunks;
-        parser[HTTPParser.kOnHeadersComplete] = (info) => {
-            this.httpVersionMajor = info.versionMajor;
-            this.httpVersionMinor = info.versionMinor;
-            this.rawHeaders = info.headers;
-            this.method = HTTPParser.methods[info.method];
-            this.url = info.url;
-        };
-        parser[HTTPParser.kOnHeaders] = (trailers) => {
-            this.rawTrailers = trailers;
-        };
-        parser[HTTPParser.kOnBody] = (chunk, offset, length) => {
-            bodyChunks = bodyChunks || [];
-            bodyChunks.push(chunk.subarray(offset, offset + length));
-        };
-        parser[HTTPParser.kOnMessageComplete] = () => {
-            this.complete = true;
-            if (bodyChunks)
-                this.body = Buffer.concat(bodyChunks);
-        };
-        const buffer = Buffer.from(buf);
-        let x = parser.execute(buffer, 0, buffer.length);
-        if (typeof x === 'object')
-            throw x;
-        if (!this.complete) {
-            x = parser.execute(CRLF);
-            if (typeof x === 'object')
-                throw x;
-        }
-        parser.finish();
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _readStream(readable) {
-        throw new Error('_readStream is not implemented yet');
-    }
-    static create(init) {
-        const msg = new HttpIncomingMessageHost();
-        if (Buffer.isBuffer(init))
-            msg._readBuffer(init);
-        else if (isReadable(init)) {
-            throw new Error('fromStream is not implemented yet');
-        }
-        else if (init)
-            msg._readConfig(init);
-        return msg;
-    }
-}
-// Apply mixins
-Object.assign(HttpIncomingMessageHost.prototype, stream.Readable.prototype);

package/esm/adapter/http/request-parsers/parse-collection-request.js

@@ -1,161 +0,0 @@
-import { BadRequestError, MethodNotAllowedError } from '@opra/common';
-import { RequestHost } from '../../request.host.js';
-export async function parseCollectionRequest(incoming, resource, url) {
-    if ((incoming.method === 'POST' || incoming.method === 'PATCH') &&
-        incoming.headers['content-type'] !== 'application/json')
-        throw new BadRequestError({ message: 'Unsupported Content-Type' });
-    url.searchParams.define({
-        '$search': { codec: 'string' },
-        '$pick': { codec: 'string', array: 'strict' },
-        '$omit': { codec: 'string', array: 'strict' },
-        '$include': { codec: 'string', array: 'strict' },
-        '$sort': { codec: 'string', array: 'strict' },
-        '$filter': { codec: 'filter' },
-        '$limit': { codec: 'number' },
-        '$skip': { codec: 'number' },
-        '$distinct': { codec: 'boolean' },
-        '$count': { codec: 'boolean' },
-    });
-    url.parse(incoming.url || '');
-    const contentId = incoming.headers['content-id'];
-    const p = url.path.get(0);
-    const params = url.searchParams;
-    switch (incoming.method) {
-        case 'POST': {
-            if (!p.key) {
-                const pick = params.get('$pick');
-                const omit = params.get('$omit');
-                const include = params.get('$include');
-                return new RequestHost({
-                    http: incoming,
-                    kind: 'CollectionCreateRequest',
-                    contentId,
-                    resource,
-                    operation: 'create',
-                    crud: 'create',
-                    many: false,
-                    args: {
-                        data: incoming.body,
-                        pick: pick && resource.normalizeFieldPath(pick),
-                        omit: omit && resource.normalizeFieldPath(omit),
-                        include: include && resource.normalizeFieldPath(include)
-                    }
-                });
-            }
-            break;
-        }
-        case 'DELETE': {
-            if (p.key) {
-                return new RequestHost({
-                    http: incoming,
-                    kind: 'CollectionDeleteRequest',
-                    contentId,
-                    resource,
-                    operation: 'delete',
-                    crud: 'delete',
-                    many: false,
-                    args: {
-                        key: resource.parseKeyValue(p.key)
-                    }
-                });
-            }
-            const filter = resource.normalizeFilter(params.get('$filter'));
-            return new RequestHost({
-                http: incoming,
-                kind: 'CollectionDeleteManyRequest',
-                contentId,
-                resource,
-                operation: 'deleteMany',
-                crud: 'delete',
-                many: true,
-                args: {
-                    filter
-                }
-            });
-        }
-        case 'GET': {
-            const pick = params.get('$pick');
-            const omit = params.get('$omit');
-            const include = params.get('$include');
-            if (p.key) {
-                return new RequestHost({
-                    http: incoming,
-                    kind: 'CollectionGetRequest',
-                    contentId,
-                    resource,
-                    operation: 'get',
-                    crud: 'read',
-                    many: false,
-                    args: {
-                        key: resource.parseKeyValue(p.key),
-                        pick: pick && resource.normalizeFieldPath(pick),
-                        omit: omit && resource.normalizeFieldPath(omit),
-                        include: include && resource.normalizeFieldPath(include)
-                    }
-                });
-            }
-            const filter = resource.normalizeFilter(params.get('$filter'));
-            const sort = params.get('$sort');
-            return new RequestHost({
-                http: incoming,
-                kind: 'CollectionFindManyRequest',
-                contentId,
-                resource,
-                operation: 'findMany',
-                crud: 'read',
-                many: true,
-                args: {
-                    pick: pick && resource.normalizeFieldPath(pick),
-                    omit: omit && resource.normalizeFieldPath(omit),
-                    include: include && resource.normalizeFieldPath(include),
-                    sort: sort && resource.normalizeSortFields(sort),
-                    filter,
-                    limit: params.get('$limit'),
-                    skip: params.get('$skip'),
-                    distinct: params.get('$distinct'),
-                    count: params.get('$count'),
-                }
-            });
-        }
-        case 'PATCH': {
-            if (p.key) {
-                const pick = params.get('$pick');
-                const omit = params.get('$omit');
-                const include = params.get('$include');
-                return new RequestHost({
-                    http: incoming,
-                    kind: 'CollectionUpdateRequest',
-                    contentId,
-                    resource,
-                    operation: 'update',
-                    crud: 'update',
-                    many: false,
-                    args: {
-                        key: resource.parseKeyValue(p.key),
-                        data: incoming.body,
-                        pick: pick && resource.normalizeFieldPath(pick),
-                        omit: omit && resource.normalizeFieldPath(omit),
-                        include: include && resource.normalizeFieldPath(include),
-                    }
-                });
-            }
-            const filter = resource.normalizeFilter(params.get('$filter'));
-            return new RequestHost({
-                http: incoming,
-                kind: 'CollectionUpdateManyRequest',
-                contentId,
-                resource,
-                operation: 'updateMany',
-                crud: 'update',
-                many: true,
-                args: {
-                    data: incoming.body,
-                    filter,
-                }
-            });
-        }
-    }
-    throw new MethodNotAllowedError({
-        message: `Collection resource does not accept http "${incoming.method}" method`
-    });
-}

package/esm/adapter/http/request-parsers/parse-request.js

@@ -1,20 +0,0 @@
-import { BadRequestError, Collection, OpraURL, Singleton } from '@opra/common';
-import { parseCollectionRequest } from './parse-collection-request.js';
-import { parseSingletonRequest } from './parse-singleton-request.js';
-export async function parseRequest(api, incoming) {
-    const url = new OpraURL(incoming.url);
-    if (!url.path.size) {
-        // Batch
-        if (incoming.headers['content-type'] === 'multipart/mixed') {
-            // todo
-        }
-        throw new BadRequestError();
-    }
-    const p = url.path.get(0);
-    const resource = api.getResource(p.resource);
-    if (resource instanceof Collection)
-        return await parseCollectionRequest(incoming, resource, url);
-    if (resource instanceof Singleton)
-        return await parseSingletonRequest(incoming, resource, url);
-    throw new BadRequestError();
-}

package/esm/adapter/http/request-parsers/parse-singleton-request.js

@@ -1,92 +0,0 @@
-import { BadRequestError, MethodNotAllowedError } from '@opra/common';
-import { RequestHost } from '../../request.host.js';
-export async function parseSingletonRequest(incoming, resource, url) {
-    if ((incoming.method === 'POST' || incoming.method === 'PATCH') &&
-        incoming.headers['content-type'] !== 'application/json')
-        throw new BadRequestError({ message: 'Unsupported Content-Type' });
-    url.searchParams.define({
-        '$pick': { codec: 'string', array: 'strict' },
-        '$omit': { codec: 'string', array: 'strict' },
-        '$include': { codec: 'string', array: 'strict' }
-    });
-    url.parse(incoming.url || '');
-    const contentId = incoming.headers['content-id'];
-    const params = url.searchParams;
-    switch (incoming.method) {
-        case 'POST': {
-            const pick = params.get('$pick');
-            const omit = params.get('$omit');
-            const include = params.get('$include');
-            return new RequestHost({
-                http: incoming,
-                kind: 'SingletonCreateRequest',
-                contentId,
-                resource,
-                operation: 'create',
-                crud: 'create',
-                many: false,
-                args: {
-                    data: incoming.body,
-                    pick: pick && resource.normalizeFieldPath(pick),
-                    omit: omit && resource.normalizeFieldPath(omit),
-                    include: include && resource.normalizeFieldPath(include),
-                }
-            });
-        }
-        case 'DELETE': {
-            return new RequestHost({
-                http: incoming,
-                kind: 'SingletonDeleteRequest',
-                contentId,
-                resource,
-                operation: 'delete',
-                crud: 'delete',
-                many: false,
-                args: {}
-            });
-        }
-        case 'GET': {
-            const pick = params.get('$pick');
-            const omit = params.get('$omit');
-            const include = params.get('$include');
-            return new RequestHost({
-                http: incoming,
-                kind: 'SingletonGetRequest',
-                contentId,
-                resource,
-                operation: 'get',
-                crud: 'read',
-                many: false,
-                args: {
-                    pick: pick && resource.normalizeFieldPath(pick),
-                    omit: omit && resource.normalizeFieldPath(omit),
-                    include: include && resource.normalizeFieldPath(include),
-                }
-            });
-        }
-        case 'PATCH': {
-            const pick = params.get('$pick');
-            const omit = params.get('$omit');
-            const include = params.get('$include');
-            return new RequestHost({
-                http: incoming,
-                kind: 'SingletonUpdateRequest',
-                contentId,
-                resource,
-                operation: 'update',
-                crud: 'update',
-                many: false,
-                args: {
-                    data: incoming.body,
-                    pick: pick && resource.normalizeFieldPath(pick),
-                    omit: omit && resource.normalizeFieldPath(omit),
-                    include: include && resource.normalizeFieldPath(include),
-                }
-            });
-        }
-        default:
-            throw new MethodNotAllowedError({
-                message: `Singleton resource does not accept http "${incoming.method}" method`
-            });
-    }
-}

package/esm/adapter/internal/metadata.resource.js

@@ -1,23 +0,0 @@
-import { __decorate, __metadata } from "tslib";
-import { ApiDocument, cloneObject, Singleton } from '@opra/common';
-export let MetadataResource = class MetadataResource {
-    constructor(document) {
-        this.document = document;
-        this._schema = document.exportSchema();
-    }
-    get() {
-        return cloneObject(this.document.exportSchema(), true);
-    }
-};
-__decorate([
-    Singleton.Get(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], MetadataResource.prototype, "get", null);
-MetadataResource = __decorate([
-    Singleton(Object, {
-        name: '$metadata',
-    }),
-    __metadata("design:paramtypes", [ApiDocument])
-], MetadataResource);

package/esm/adapter/request-context.host.js

@@ -1,40 +0,0 @@
-import { AsyncEventEmitter } from 'strict-typed-events';
-export class RequestContextHost extends AsyncEventEmitter {
-    constructor(protocol, platform, api, _request, _response) {
-        super();
-        this.protocol = protocol;
-        this.platform = platform;
-        this.api = api;
-        this._request = _request;
-        this._response = _response;
-        if (this.protocol === 'http') {
-            this._http = {
-                platform,
-                request: this._request.switchToHttp(),
-                response: this._response.switchToHttp(),
-                switchToContext: () => this
-            };
-        }
-    }
-    get request() {
-        return this._request;
-    }
-    get response() {
-        return this._response;
-    }
-    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');
-    }
-}

package/esm/shared/collection-resource-base.js

@@ -1,16 +0,0 @@
-import { METADATA_KEY } from '@opra/common';
-export class CollectionResourceBase {
-    constructor(options) {
-        this.defaultLimit = options?.defaultLimit || 100;
-        if (options?.operations) {
-            const m = Reflect.getMetadata(METADATA_KEY, Object.getPrototypeOf(this).constructor);
-            if (m?.operations)
-                Object.keys(m.operations).forEach(k => {
-                    if (!options.operations?.includes(k)) {
-                        const operation = m.operations[k];
-                        this[operation.handlerName] = null;
-                    }
-                });
-        }
-    }
-}

package/types/adapter/http/request-parsers/parse-collection-request.d.ts

@@ -1,4 +0,0 @@
-import { Collection, OpraURL } from '@opra/common';
-import { Request } from '../../interfaces/request.interface.js';
-import { HttpServerRequest } from '../impl/http-server-request.js';
-export declare function parseCollectionRequest(incoming: HttpServerRequest, resource: Collection, url: OpraURL): Promise<Request>;

package/types/adapter/http/request-parsers/parse-request.d.ts

@@ -1,4 +0,0 @@
-import { ApiDocument } from '@opra/common';
-import { Request } from '../../interfaces/request.interface.js';
-import { HttpServerRequest } from '../impl/http-server-request.js';
-export declare function parseRequest(api: ApiDocument, incoming: HttpServerRequest): Promise<Request>;

package/types/adapter/http/request-parsers/parse-singleton-request.d.ts

@@ -1,4 +0,0 @@
-import { OpraURL, Singleton } from '@opra/common';
-import { Request } from '../../interfaces/request.interface.js';
-import { HttpServerRequest } from '../impl/http-server-request.js';
-export declare function parseSingletonRequest(incoming: HttpServerRequest, resource: Singleton, url: OpraURL): Promise<Request>;

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

@@ -1,31 +0,0 @@
-import { ApiDocument } from '@opra/common';
-import { HttpServerRequest } from '../http/impl/http-server-request.js';
-import { HttpServerResponse } from '../http/impl/http-server-response.js';
-import { Request } from './request.interface.js';
-import { Response } from './response.interface.js';
-export declare namespace RequestContext {
-    type Protocol = 'http' | 'ws' | 'rpc';
-}
-export interface RequestContext {
-    readonly protocol: RequestContext.Protocol;
-    readonly platform: string;
-    readonly api: ApiDocument;
-    readonly request: Request;
-    readonly response: Response;
-    user?: any;
-    switchToHttp(): HttpMessageContext;
-    switchToWs(): WsMessageContext;
-    switchToRpc(): RpcMessageContext;
-}
-export interface HttpMessageContext {
-    readonly platform: string;
-    readonly request: HttpServerRequest;
-    readonly response: HttpServerResponse;
-    switchToContext(): RequestContext;
-}
-export interface WsMessageContext {
-    switchToContext(): RequestContext;
-}
-export interface RpcMessageContext {
-    switchToContext(): RequestContext;
-}

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

@@ -1,15 +0,0 @@
-import { OpraSchema, Resource } from '@opra/common';
-import { HttpServerRequest } from '../http/impl/http-server-request.js';
-export interface Request {
-    readonly contentId: string;
-    readonly kind: string;
-    readonly resource: Resource;
-    readonly resourceKind: OpraSchema.Resource.Kind;
-    readonly operation: string;
-    readonly crud: 'create' | 'read' | 'update' | 'delete';
-    readonly many: boolean;
-    readonly args: any;
-    switchToHttp(): HttpServerRequest;
-    switchToWs(): never;
-    switchToRpc(): never;
-}

package/types/adapter/internal/metadata.resource.d.ts

@@ -1,7 +0,0 @@
-import { ApiDocument } from '@opra/common';
-export declare class MetadataResource {
-    readonly document: ApiDocument;
-    private _schema;
-    constructor(document: ApiDocument);
-    get(): import("@opra/common/types/schema/document.interface").ApiDocument;
-}

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

@@ -1,22 +0,0 @@
-import { AsyncEventEmitter } from 'strict-typed-events';
-import { ApiDocument } from '@opra/common';
-import { Request } from './interfaces/request.interface.js';
-import { HttpMessageContext, RequestContext, RpcMessageContext, WsMessageContext } from './interfaces/request-context.interface.js';
-import { Response } from './interfaces/response.interface.js';
-export declare class RequestContextHost extends AsyncEventEmitter implements RequestContext {
-    readonly protocol: RequestContext.Protocol;
-    readonly platform: string;
-    readonly api: ApiDocument;
-    protected _request: Request;
-    protected _response: Response;
-    user?: any;
-    protected _http?: HttpMessageContext;
-    protected _ws?: WsMessageContext;
-    protected _rpc?: RpcMessageContext;
-    constructor(protocol: RequestContext.Protocol, platform: string, api: ApiDocument, _request: Request, _response: Response);
-    get request(): Request;
-    get response(): Response;
-    switchToHttp(): HttpMessageContext;
-    switchToWs(): WsMessageContext;
-    switchToRpc(): RpcMessageContext;
-}

package/types/shared/collection-resource-base.d.ts

@@ -1,11 +0,0 @@
-import { OpraSchema } from '@opra/common';
-export declare namespace CollectionResourceBase {
-    interface Options {
-        defaultLimit?: number;
-        operations?: (keyof OpraSchema.Collection.Operations)[];
-    }
-}
-export declare class CollectionResourceBase {
-    defaultLimit?: number;
-    constructor(options?: CollectionResourceBase.Options);
-}