@opra/core 0.25.5 → 0.26.0

package/esm/http/request-handlers/storage-request-handler.js

@@ -1,134 +0,0 @@
-import fs from 'fs/promises';
-import os from 'os';
-import { BadRequestError, HttpStatusCodes, isReadable, OpraException, Storage, uid } from '@opra/common';
-import { EndpointContext } from '../../endpoint-context.js';
-import { RequestHost } from '../../request.host.js';
-import { ResponseHost } from '../../response.host.js';
-import { MultipartIterator } from '../helpers/multipart-helper.js';
-import { RequestHandlerBase } from './request-handler-base.js';
-/**
- * @class StorageRequestHandler
- */
-export class StorageRequestHandler extends RequestHandlerBase {
-    constructor(adapter, options) {
-        super(adapter);
-        this.adapter = adapter;
-        this._uploadDir = options?.uploadDir || os.tmpdir();
-    }
-    async processRequest(executionContext) {
-        const { incoming, outgoing } = executionContext.switchToHttp();
-        // Parse incoming message and create Request object
-        const request = await this.parseRequest(executionContext, incoming);
-        if (!request)
-            return;
-        const response = new ResponseHost({ http: outgoing });
-        const context = EndpointContext.from(executionContext, request, response);
-        await this.callEndpoint(context);
-        if (response.errors.length) {
-            context.errors.push(...response.errors);
-            return;
-        }
-        await this.sendResponse(context);
-    }
-    async parseRequest(executionContext, incoming) {
-        const contentId = incoming.headers['content-id'];
-        const p = incoming.parsedUrl.path[0];
-        const resource = this.adapter.api.getResource(p.resource);
-        try {
-            if (!(resource instanceof Storage))
-                return;
-            switch (incoming.method) {
-                case 'GET': {
-                    const endpointMeta = await this.assertEndpoint(resource, 'get');
-                    return new RequestHost({
-                        controller: endpointMeta.controller,
-                        http: incoming,
-                        resource,
-                        endpoint: 'get',
-                        contentId,
-                        path: incoming.parsedUrl.path.slice(1).toString().substring(1),
-                        params: this.parseParameters(incoming.parsedUrl, endpointMeta)
-                    });
-                }
-                case 'DELETE': {
-                    const endpointMeta = await this.assertEndpoint(resource, 'delete');
-                    return new RequestHost({
-                        controller: endpointMeta.controller,
-                        http: incoming,
-                        resource,
-                        endpoint: 'delete',
-                        contentId,
-                        path: incoming.parsedUrl.path.slice(1).toString().substring(1),
-                        params: this.parseParameters(incoming.parsedUrl, endpointMeta)
-                    });
-                }
-                case 'POST': {
-                    const endpointMeta = await this.assertEndpoint(resource, 'post');
-                    await fs.mkdir(this._uploadDir, { recursive: true });
-                    const multipartIterator = new MultipartIterator(incoming, {
-                        ...endpointMeta,
-                        filename: () => this.adapter.serviceName + '_p' + process.pid +
-                            't' + String(Date.now()).substring(8) + 'r' + uid(12)
-                    });
-                    multipartIterator.pause();
-                    // Add an hook to clean up files after request finished
-                    executionContext.on('finish', async () => {
-                        multipartIterator.cancel();
-                        await multipartIterator.deleteFiles().catch(() => void 0);
-                    });
-                    return new RequestHost({
-                        controller: endpointMeta.controller,
-                        http: incoming,
-                        resource,
-                        endpoint: 'post',
-                        contentId,
-                        parts: multipartIterator,
-                        path: incoming.parsedUrl.path.slice(1).toString().substring(1),
-                        params: this.parseParameters(incoming.parsedUrl, endpointMeta)
-                    });
-                }
-            }
-        }
-        catch (e) {
-            if (e instanceof OpraException)
-                throw e;
-            throw new BadRequestError(e);
-        }
-    }
-    async callEndpoint(context) {
-        const request = context.request;
-        const { response } = context;
-        // Call endpoint handler method
-        let value;
-        try {
-            value = await request.controller[request.endpoint].call(request.controller, context);
-            if (response.value == null)
-                response.value = value;
-        }
-        catch (error) {
-            response.errors.push(error);
-        }
-    }
-    async sendResponse(context) {
-        const { response } = context;
-        const outgoing = response.switchToHttp();
-        outgoing.statusCode = outgoing.statusCode || HttpStatusCodes.OK;
-        if (response.value != null) {
-            if (typeof response.value === 'string') {
-                if (!outgoing.hasHeader('content-type'))
-                    outgoing.setHeader('content-type', 'text/plain');
-                outgoing.send(response.value);
-            }
-            else if (Buffer.isBuffer(response.value) || isReadable(response.value)) {
-                if (!outgoing.hasHeader('content-type'))
-                    outgoing.setHeader('content-type', 'application/octet-stream');
-                outgoing.send(response.value);
-            }
-            else {
-                outgoing.setHeader('content-type', 'application/json; charset=utf-8');
-                outgoing.send(JSON.stringify(response.value));
-            }
-        }
-        outgoing.end();
-    }
-}

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

@@ -1,11 +0,0 @@
-import type { Application } from 'express';
-import { ApiDocument } from '@opra/common';
-import type { ExpressAdapter } from './express-adapter.js';
-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/http/http-adapter-base.d.ts

@@ -1,23 +0,0 @@
-import { ExecutionContext } from '../execution-context.js';
-import { RequestHandler } from '../interfaces/request-handler.interface.js';
-import { PlatformAdapterHost } from '../platform-adapter.host.js';
-import type { Protocol } from '../platform-adapter.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/http/http-adapter.host.d.ts

@@ -1,18 +0,0 @@
-/// <reference types="node" />
-import http from 'http';
-import { ApiDocument, OpraURLPath } from '@opra/common';
-import type { HttpAdapter } from './http-adapter.js';
-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/http/request-handlers/entity-request-handler.d.ts

@@ -1,24 +0,0 @@
-import { Collection, OpraSchema, Singleton } from '@opra/common';
-import { EndpointContext } from '../../endpoint-context.js';
-import { ExecutionContext } from '../../execution-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>;
-    callEndpoint(context: EndpointContext): Promise<void>;
-    sendResponse(context: EndpointContext): Promise<void>;
-    parseCollectionRequest(resource: Collection, incoming: HttpServerRequest): Promise<Request>;
-    parseSingletonRequest(resource: Singleton, incoming: HttpServerRequest): Promise<Request>;
-    getBodyLoader(endpoint: OpraSchema.Collection.CreateEndpoint | OpraSchema.Collection.UpdateEndpoint | OpraSchema.Collection.UpdateManyEndpoint): BodyLoaderFunction;
-}
-export {};

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

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

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

@@ -1,23 +0,0 @@
-import { EndpointContext } from '../../endpoint-context.js';
-import type { ExecutionContext } from '../../execution-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>;
-    callEndpoint(context: EndpointContext): Promise<void>;
-    sendResponse(context: EndpointContext): Promise<void>;
-}