@opra/core 0.25.4 → 0.26.0

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

@@ -1,128 +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
-                    });
-                }
-                case 'DELETE': {
-                    const endpointMeta = await this.assertEndpoint(resource, 'delete');
-                    return new RequestHost({
-                        controller: endpointMeta.controller,
-                        http: incoming,
-                        resource,
-                        endpoint: 'delete',
-                        contentId
-                    });
-                }
-                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
-                    });
-                }
-            }
-        }
-        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/esm/adapter/platform-adapter.host.js

@@ -1,103 +0,0 @@
-import path from 'path';
-import { pascalCase } from 'putil-varhelpers';
-import { AsyncEventEmitter } from 'strict-typed-events';
-import { getStackFileName, I18n, Resource } from '@opra/common';
-import { Logger } from './services/logger.js';
-/**
- * @class PlatformAdapterHost
- */
-export class PlatformAdapterHost extends AsyncEventEmitter {
-    constructor(api, options) {
-        super();
-        this.api = api;
-        this._controllers = new WeakMap();
-        this._initialized = false;
-        this._options = options || {};
-        this._interceptors = [...(options?.interceptors || [])];
-        this._logger = options?.logger && options.logger instanceof Logger
-            ? options.logger
-            : new Logger({ instance: options?.logger });
-        // Assign events
-        if (options?.on) {
-            for (const [event, fn] of Object.entries(options.on)) {
-                /* istanbul ignore next */
-                if (typeof fn === 'function')
-                    this.on(event, fn);
-            }
-        }
-        // Make a safe service name
-        this._serviceName = pascalCase((api.info.title || '').replace(/[^a-z0-9_ ]/ig, '')) || 'OpraService';
-        if (!/^[a-z]/i.test(this._serviceName))
-            this._serviceName = 'X' + this._serviceName;
-    }
-    get platform() {
-        return this._platform;
-    }
-    get protocol() {
-        return this._protocol;
-    }
-    get serviceName() {
-        return this.api.info.title;
-    }
-    async close() {
-        const promises = [];
-        for (const r of this.api.resources.values()) {
-            const onShutdown = r.onShutdown;
-            if (onShutdown)
-                promises.push((async () => onShutdown.call(r.controller, r))());
-        }
-        await Promise.allSettled(promises);
-    }
-    /**
-     * Initializes the adapter
-     */
-    async init() {
-        if (this._initialized)
-            return;
-        // Init I18n
-        if (this._options?.i18n instanceof I18n)
-            this._i18n = this._options.i18n;
-        else if (typeof this._options?.i18n === 'function')
-            this._i18n = await this._options.i18n();
-        else
-            this._i18n = await this._createI18n(this._options?.i18n);
-        this._i18n = this._i18n || I18n.defaultInstance;
-        if (!this._i18n.isInitialized)
-            await this._i18n.init();
-        // Initialize all resources
-        for (const resource of this.api.resources.values()) {
-            await this.getController(resource);
-        }
-        this._initialized = true;
-    }
-    async getController(resource) {
-        resource = typeof resource === 'object' && resource instanceof Resource
-            ? resource : this.api.getResource(resource);
-        let controller = this._controllers.get(resource);
-        if (!controller) {
-            if (resource.controller) {
-                controller = typeof resource.controller === 'function' ?
-                    new resource.controller()
-                    : resource.controller;
-                // Initialize controller
-                if (typeof controller.onInit === 'function')
-                    await controller.onInit.call(controller);
-                this._controllers.set(resource, controller);
-            }
-        }
-        return controller;
-    }
-    async _createI18n(options) {
-        const opts = {
-            ...options,
-        };
-        delete opts.resourceDirs;
-        const instance = I18n.createInstance(opts);
-        await instance.init();
-        await instance.loadResourceDir(path.resolve(getStackFileName(), '../../../i18n'));
-        if (options?.resourceDirs)
-            for (const dir of options.resourceDirs)
-                await instance.loadResourceDir(dir);
-        return instance;
-    }
-}

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

@@ -1,10 +0,0 @@
-import type { ExecutionContext } from './execution-context';
-import type { Request } from './request';
-import type { Response } from './response';
-export interface EndpointContext<TSession extends {} = {}> extends ExecutionContext<TSession> {
-    request: Request;
-    response: Response;
-}
-export declare namespace EndpointContext {
-    function from(executionContext: ExecutionContext, request: Request, response: Response): EndpointContext;
-}

package/types/adapter/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';
-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/http-adapter-base.d.ts

@@ -1,23 +0,0 @@
-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.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';
-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/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/adapter/http/request-handlers/request-handler-base.d.ts

@@ -1,15 +0,0 @@
-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>;
-    assertEndpoint<T extends OpraSchema.Endpoint = OpraSchema.Endpoint>(resource: Resource, endpoint: string): Promise<T & {
-        controller: any;
-    }>;
-}

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

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

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

@@ -1,33 +0,0 @@
-import { AsyncEventEmitter } from 'strict-typed-events';
-import { ApiDocument, I18n, Resource } from '@opra/common';
-import { ExecutionContext } from './execution-context.js';
-import { Interceptor } from './interfaces/interceptor.interface.js';
-import type { PlatformAdapter, Protocol } from './platform-adapter';
-import { Logger } from './services/logger.js';
-/**
- * @class PlatformAdapterHost
- */
-export declare abstract class PlatformAdapterHost extends AsyncEventEmitter implements PlatformAdapter {
-    readonly api: ApiDocument;
-    _controllers: WeakMap<Resource, any>;
-    _protocol: Protocol;
-    _platform: string;
-    _initialized: boolean;
-    _serviceName: string;
-    _options: PlatformAdapter.Options;
-    _i18n: I18n;
-    _logger: Logger;
-    _interceptors: Interceptor[];
-    protected constructor(api: ApiDocument, options?: PlatformAdapter.Options);
-    get platform(): string;
-    get protocol(): Protocol;
-    get serviceName(): string;
-    close(): Promise<void>;
-    /**
-     * Initializes the adapter
-     */
-    init(): Promise<void>;
-    getController(resource: Resource | string): Promise<any>;
-    protected _createI18n(options?: PlatformAdapter.I18nOptions): Promise<I18n>;
-    abstract processRequest(executionContext: ExecutionContext): Promise<void>;
-}