@opra/core 0.25.5 → 0.26.1

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

@@ -0,0 +1,34 @@
+import { Collection, OpraURLPath, OpraURLPathComponent, Parameter, Resource, Singleton, Storage } from '@opra/common';
+import { ExecutionContext } from '../execution-context.js';
+import { PlatformAdapterHost } from '../platform-adapter.host.js';
+import type { Protocol } from '../platform-adapter.js';
+import { RequestHost } from '../request.host.js';
+import { Request } from '../request.js';
+import { RequestContext } from '../request-context.js';
+import { HttpServerRequest } from './http-server-request.js';
+import { HttpServerResponse } from './http-server-response.js';
+/**
+ *
+ * @class HttpAdapterHost
+ */
+export declare abstract class HttpAdapterHost extends PlatformAdapterHost {
+    protected _protocol: Protocol;
+    protected _tempDir: string;
+    /**
+     * Main http request handler
+     * @param incoming
+     * @param outgoing
+     * @protected
+     */
+    protected handleHttp(incoming: HttpServerRequest, outgoing: HttpServerResponse): Promise<void>;
+    handleExecution(executionContext: ExecutionContext): Promise<void>;
+    parseRequest(executionContext: ExecutionContext): Promise<Request>;
+    protected _parseRequestAction(executionContext: ExecutionContext, resource: Resource, urlPath: OpraURLPath, searchParams: URLSearchParams): Promise<RequestHost>;
+    protected _parseRequestCollection(executionContext: ExecutionContext, resource: Collection, urlPath: OpraURLPath, searchParams: URLSearchParams): Promise<RequestHost>;
+    protected _parseRequestSingleton(executionContext: ExecutionContext, resource: Singleton, urlPath: OpraURLPath, searchParams?: URLSearchParams): Promise<RequestHost>;
+    protected _parseRequestStorage(executionContext: ExecutionContext, resource: Storage, urlPath: OpraURLPath, searchParams: URLSearchParams): Promise<RequestHost>;
+    protected parseParameters(paramDefs: Map<string, Parameter>, pathComponent: OpraURLPathComponent, searchParams?: URLSearchParams): Record<string, any>;
+    protected executeRequest(context: RequestContext): Promise<void>;
+    sendResponse(context: RequestContext): Promise<void>;
+    protected handleError(context: ExecutionContext): Promise<void>;
+}

package/types/index.d.ts

@@ -1,16 +1,17 @@
 import "reflect-metadata";
 import './augmentation/resource.augmentation.js';
 import './augmentation/collection.augmentation.js';
+import './augmentation/container.augmentation.js';
 import './augmentation/singleton.augmentation.js';
 import './augmentation/storage.augmentation.js';
 export * from './types.js';
 export * from './execution-context.js';
-export * from './endpoint-context.js';
+export * from './request-context.js';
 export * from './platform-adapter.js';
 export * from './request.js';
 export * from './response.js';
-export * from './http/express-adapter.js';
-export * from './http/http-adapter.js';
+export * from './http/adapters/express-adapter.js';
+export * from './http/adapters/node-http-adapter.js';
 export * from './http/impl/http-incoming-message.host.js';
 export * from './http/impl/http-outgoing-message.host.js';
 export * from './http/http-server-request.js';

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

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

package/types/platform-adapter.d.ts

@@ -1,8 +1,8 @@
 import { ApiDocument, FallbackLng, I18n, LanguageResource } from '@opra/common';
-import { EndpointContext } from './endpoint-context.js';
 import { Interceptor } from './interfaces/interceptor.interface.js';
 import { ILogger } from './interfaces/logger.interface.js';
 import { RequestHandler } from './interfaces/request-handler.interface.js';
+import { RequestContext } from './request-context.js';
 export type Protocol = 'http' | 'ws' | 'rpc';
 export interface PlatformAdapter extends RequestHandler {
     readonly api: ApiDocument;
@@ -23,7 +23,7 @@ export declare namespace PlatformAdapter {
         logger?: ILogger;
         interceptors?: Interceptor[];
         on?: {
-            request?: (ctx: EndpointContext) => void | Promise<void>;
+            request?: (ctx: RequestContext) => void | Promise<void>;
         };
     }
     interface I18nOptions {

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

@@ -1,5 +1,5 @@
 import { AsyncEventEmitter } from 'strict-typed-events';
-import { ApiDocument, I18n, Resource } from '@opra/common';
+import { ApiDocument, Endpoint, 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.js';
@@ -8,26 +8,30 @@ 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);
+    protected _api: ApiDocument;
+    protected _controllers: Map<Resource, any>;
+    protected _protocol: Protocol;
+    protected _platform: string;
+    protected _serviceName: string;
+    protected _i18n: I18n;
+    protected _logger: Logger;
+    protected _interceptors: Interceptor[];
+    get api(): ApiDocument;
     get platform(): string;
     get protocol(): Protocol;
     get serviceName(): string;
+    get i18n(): I18n;
     close(): Promise<void>;
     /**
      * Initializes the adapter
      */
-    init(): Promise<void>;
+    protected init(api: ApiDocument, options?: PlatformAdapter.Options): Promise<void>;
     getController(resource: Resource | string): Promise<any>;
+    getOperationHandler(resource: Resource | string, operationOrAction: string): Promise<{
+        endpoint: Endpoint;
+        controller: any;
+        handler: Function;
+    }>;
     protected _createI18n(options?: PlatformAdapter.I18nOptions): Promise<I18n>;
-    abstract processRequest(executionContext: ExecutionContext): Promise<void>;
+    abstract handleExecution(executionContext: ExecutionContext): Promise<void>;
 }

package/types/{endpoint-context.d.ts → request-context.d.ts}

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

package/types/request.d.ts

@@ -1,8 +1,13 @@
-import { Resource } from '@opra/common';
+import { Endpoint, Resource } from '@opra/common';
 import { HttpServerRequest } from './http/http-server-request.js';
 export interface Request {
     resource: Resource;
-    endpoint: string;
+    endpoint: Endpoint;
+    operation: string;
+    key?: any;
+    action?: string;
+    controller: Object;
+    handler: Function;
     contentId?: string;
     params: Record<string, any>;
     switchToHttp(): HttpServerRequest;

package/types/request.host.d.ts

@@ -1,9 +1,11 @@
 import type { PartialSome, StrictOmit } from 'ts-gems';
+import type { Resource } from '@opra/common';
 import type { HttpServerRequest } from './http/http-server-request.js';
 import type { Request } from './request.js';
 export declare namespace RequestHost {
-    interface Initiator extends PartialSome<StrictOmit<Request, 'switchToHttp' | 'switchToWs' | 'switchToRpc'>, 'params'> {
-        controller: any;
+    interface Initiator extends PartialSome<StrictOmit<Request, 'resource' | 'switchToHttp' | 'switchToWs' | 'switchToRpc'>, 'params'> {
+        controller: Object;
+        handler: Function;
         http?: HttpServerRequest;
         [key: string]: any;
     }
@@ -16,6 +18,7 @@ export declare class RequestHost implements Request {
     key?: any;
     params: Record<string, any>;
     constructor(init: RequestHost.Initiator);
+    get resource(): Resource;
     switchToHttp(): HttpServerRequest;
     switchToWs(): never;
     switchToRpc(): never;

package/cjs/http/express-adapter.host.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpressAdapterHost = void 0;
-const common_1 = require("@opra/common");
-const http_adapter_base_js_1 = require("./http-adapter-base.js");
-const http_server_request_js_1 = require("./http-server-request.js");
-const http_server_response_js_1 = require("./http-server-response.js");
-class ExpressAdapterHost extends http_adapter_base_js_1.HttpAdapterBase {
-    constructor(app, api, options) {
-        super(api, options);
-        this._platform = 'express';
-        const basePath = new common_1.OpraURLPath(options?.basePath);
-        app.use(basePath.toString(), (_req, _res) => {
-            const req = http_server_request_js_1.HttpServerRequest.from(_req);
-            const res = http_server_response_js_1.HttpServerResponse.from(_res);
-            this.handleIncoming(req, res)
-                .catch(() => void 0);
-        });
-    }
-    get app() {
-        return this._app;
-    }
-}
-exports.ExpressAdapterHost = ExpressAdapterHost;

package/cjs/http/http-adapter-base.js

@@ -1,138 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpAdapterBase = void 0;
-const common_1 = require("@opra/common");
-const execution_context_host_js_1 = require("../execution-context.host.js");
-const platform_adapter_host_js_1 = require("../platform-adapter.host.js");
-const entity_request_handler_js_1 = require("./request-handlers/entity-request-handler.js");
-const storage_request_handler_js_1 = require("./request-handlers/storage-request-handler.js");
-/**
- *
- * @class HttpAdapterBase
- */
-class HttpAdapterBase extends platform_adapter_host_js_1.PlatformAdapterHost {
-    constructor() {
-        super(...arguments);
-        this._protocol = 'http';
-        this._requestHandlers = [
-            new entity_request_handler_js_1.EntityRequestHandler(this),
-            new storage_request_handler_js_1.StorageRequestHandler(this)
-        ];
-    }
-    /**
-     * Main http request handler
-     * @param incoming
-     * @param outgoing
-     * @protected
-     */
-    async handleIncoming(incoming, outgoing) {
-        const context = new execution_context_host_js_1.ExecutionContextHost(this.api, this.platform, { http: { incoming, outgoing } });
-        try {
-            /* istanbul ignore next */
-            if (!this._initialized)
-                throw new common_1.InternalServerError(`${Object.getPrototypeOf(this).constructor.name} has not been initialized yet`);
-            outgoing.setHeader(common_1.HttpHeaderCodes.X_Opra_Version, common_1.OpraSchema.SpecVersion);
-            // Expose headers if cors enabled
-            if (outgoing.getHeader(common_1.HttpHeaderCodes.Access_Control_Allow_Origin)) {
-                // Expose X-Opra-* headers
-                outgoing.appendHeader(common_1.HttpHeaderCodes.Access_Control_Expose_Headers, Object.values(common_1.HttpHeaderCodes)
-                    .filter(k => k.toLowerCase().startsWith('x-opra-')));
-            }
-            let i = 0;
-            let requestProcessed = false;
-            const next = async () => {
-                while (i < this._interceptors.length) {
-                    const interceptor = this._interceptors[i++];
-                    if (interceptor)
-                        await interceptor(context, next);
-                }
-                if (!requestProcessed) {
-                    requestProcessed = true;
-                    await this.processRequest(context);
-                }
-            };
-            await next();
-        }
-        catch (error) {
-            context.errors.push((0, common_1.wrapException)(error));
-        }
-        // If no response returned to the client we send an error
-        if (!outgoing.writableEnded) {
-            if (!context.errors.length)
-                context.errors.push(new common_1.BadRequestError(`Server can not process this request`));
-            await this.handleError(context);
-        }
-    }
-    async processRequest(context) {
-        try {
-            const { incoming, outgoing } = context.switchToHttp();
-            if (incoming.method === 'GET' && !incoming.parsedUrl.path.length) {
-                outgoing.setHeader('content-type', 'application/json');
-                outgoing.end(JSON.stringify(this.api.exportSchema({ webSafe: true })));
-                return;
-            }
-            const { parsedUrl } = incoming;
-            if (!parsedUrl.path.length) {
-                // Batch
-                if (incoming.headers['content-type'] === 'multipart/mixed') {
-                    // todo
-                }
-                throw new common_1.BadRequestError();
-            }
-            // Iterate through request handlers until one of them sends response (end outgoing stream)
-            for (const requestHandler of this._requestHandlers) {
-                await requestHandler.processRequest(context);
-                if (outgoing.writableEnded)
-                    return;
-                if (context.errors.length) {
-                    await this.handleError(context);
-                    return;
-                }
-            }
-        }
-        finally {
-            await context.emitAsync('finish');
-        }
-    }
-    async handleError(context) {
-        const { errors } = context;
-        const { outgoing } = context.switchToHttp();
-        if (outgoing.headersSent) {
-            outgoing.end();
-            return;
-        }
-        errors.forEach(x => {
-            // todo. implement a better log mechanism
-            if (x instanceof common_1.OpraException)
-                this._logger.fatal(x);
-            else
-                this._logger.error(x);
-        });
-        const wrappedErrors = errors.map(common_1.wrapException);
-        // Sort errors from fatal to info
-        wrappedErrors.sort((a, b) => {
-            const i = common_1.IssueSeverity.Keys.indexOf(a.severity) - common_1.IssueSeverity.Keys.indexOf(b.severity);
-            if (i === 0)
-                return b.status - a.status;
-            return i;
-        });
-        let status = outgoing.statusCode || 0;
-        if (!status || status < Number(common_1.HttpStatusCodes.BAD_REQUEST)) {
-            status = wrappedErrors[0].status;
-            if (status < Number(common_1.HttpStatusCodes.BAD_REQUEST))
-                status = common_1.HttpStatusCodes.INTERNAL_SERVER_ERROR;
-        }
-        outgoing.statusCode = status;
-        const body = {
-            errors: wrappedErrors.map(x => this._i18n.deep(x.toJSON()))
-        };
-        outgoing.setHeader(common_1.HttpHeaderCodes.Content_Type, 'application/opra+json; charset=utf-8');
-        outgoing.setHeader(common_1.HttpHeaderCodes.Cache_Control, 'no-cache');
-        outgoing.setHeader(common_1.HttpHeaderCodes.Pragma, 'no-cache');
-        outgoing.setHeader(common_1.HttpHeaderCodes.Expires, '-1');
-        outgoing.setHeader(common_1.HttpHeaderCodes.X_Opra_Version, common_1.OpraSchema.SpecVersion);
-        outgoing.send(JSON.stringify(body));
-        outgoing.end();
-    }
-}
-exports.HttpAdapterBase = HttpAdapterBase;

package/cjs/http/http-adapter.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpAdapter = void 0;
-const http_adapter_host_js_1 = require("./http-adapter.host.js");
-/**
- * @namespace HttpAdapter
- */
-var HttpAdapter;
-(function (HttpAdapter) {
-    async function create(api, options) {
-        const adapter = new http_adapter_host_js_1.HttpAdapterHost(api, options);
-        await adapter.init();
-        return adapter;
-    }
-    HttpAdapter.create = create;
-})(HttpAdapter || (exports.HttpAdapter = HttpAdapter = {}));