@opra/core 0.22.0 → 0.23.0

package/types/adapter/{adapter.d.ts → platform-adapter.d.ts}

@@ -1,15 +1,27 @@
-import { AsyncEventEmitter } from 'strict-typed-events';
-import { ApiDocument, FallbackLng, I18n, LanguageResource } from '@opra/common';
+import { FallbackLng, I18n, LanguageResource } from '@opra/common';
 import { ILogger } from './interfaces/logger.interface.js';
-import { RequestContext } from './interfaces/request-context.interface.js';
+import { RequestHandler } from './interfaces/request-handler.interface.js';
+import { OperationContext } from './operation-context.js';
+export type Protocol = 'http' | 'ws' | 'rpc';
+export interface PlatformAdapter extends RequestHandler {
+    readonly protocol: Protocol;
+    readonly platform: string;
+    readonly serviceName: string;
+    /**
+     * Calls shutDown hook for all resources
+     */
+    close(): Promise<void>;
+}
 /**
- * @namespace OpraAdapter
+ * @namespace PlatformAdapter
  */
-export declare namespace OpraAdapter {
+export declare namespace PlatformAdapter {
     interface Options {
         i18n?: I18n | I18nOptions | (() => Promise<I18n>);
         logger?: ILogger;
-        onRequest?: (ctx: RequestContext) => void | Promise<void>;
+        on?: {
+            request?: (ctx: OperationContext) => void | Promise<void>;
+        };
     }
     interface I18nOptions {
         /**
@@ -39,25 +51,3 @@ export declare namespace OpraAdapter {
         resourceDirs?: string[];
     }
 }
-/**
- * @class OpraAdapter
- */
-export declare abstract class OpraAdapter extends AsyncEventEmitter {
-    readonly api: ApiDocument;
-    protected _apiRoot: ApiDocument;
-    i18n: I18n;
-    logger?: ILogger;
-    protected constructor(api: ApiDocument);
-    /**
-     * Initializes the adapter
-     * @param options
-     * @protected
-     */
-    protected init(options?: OpraAdapter.Options): Promise<void>;
-    /**
-     * Calls shutDown hook for all resources
-     */
-    close(): Promise<void>;
-    protected executeRequest(context: RequestContext): Promise<void>;
-    protected _createI18n(options?: OpraAdapter.I18nOptions): Promise<I18n>;
-}

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

@@ -0,0 +1,31 @@
+import { AsyncEventEmitter } from 'strict-typed-events';
+import { ApiDocument, I18n, Resource } from '@opra/common';
+import { ExecutionContext } from './execution-context.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;
+    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>;
+}

package/types/adapter/request.d.ts

@@ -0,0 +1,11 @@
+import { Resource } from '@opra/common';
+import { HttpServerRequest } from './http/http-server-request.js';
+export interface Request {
+    resource: Resource;
+    operation: string;
+    contentId?: string;
+    params?: Record<string, any>;
+    switchToHttp(): HttpServerRequest;
+    switchToWs(): never;
+    switchToRpc(): never;
+}

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

@@ -1,29 +1,20 @@
-import type { Resource } from '@opra/common';
-import { OpraSchema } from '@opra/common';
-import { HttpServerRequest } from './http/impl/http-server-request.js';
-import type { Request } from './interfaces/request.interface.js';
+import type { StrictOmit } from 'ts-gems';
+import type { HttpServerRequest } from './http/http-server-request.js';
+import type { Request } from './request';
 export declare namespace RequestHost {
-    interface Initiator {
-        contentId?: string;
-        kind: string;
-        resource: Resource;
-        operation: string;
-        crud: 'create' | 'read' | 'update' | 'delete';
-        many: boolean;
-        args: any;
+    interface Initiator extends StrictOmit<Request, 'switchToHttp' | 'switchToWs' | 'switchToRpc'> {
+        controller: any;
         http?: HttpServerRequest;
+        [key: string]: any;
     }
 }
+export interface RequestHost extends Request {
+}
 export declare class RequestHost implements 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;
-    readonly http?: HttpServerRequest;
+    controller: any;
+    http?: HttpServerRequest;
+    key?: any;
+    params: Record<string, any>;
     constructor(init: RequestHost.Initiator);
     switchToHttp(): HttpServerRequest;
     switchToWs(): never;

package/types/adapter/{interfaces/response.interface.d.ts → response.d.ts}

@@ -1,4 +1,4 @@
-import { HttpServerResponse } from '../http/impl/http-server-response.js';
+import type { HttpServerResponse } from './http/http-server-response';
 export interface Response {
     /**
      * Result value
@@ -7,7 +7,7 @@ export interface Response {
     /**
      * List of errors
      */
-    errors: Error[];
+    errors: any[];
     /**
      *
      */

package/types/adapter/response.host.d.ts

@@ -1,5 +1,5 @@
-import { HttpServerResponse } from './http/impl/http-server-response.js';
-import { Response } from './interfaces/response.interface.js';
+import type { HttpServerResponse } from './http/http-server-response';
+import type { Response } from './response';
 export declare namespace ResponseHost {
     interface Initiator {
         value?: any;

package/types/adapter/services/logger.d.ts

@@ -0,0 +1,14 @@
+import { ILogger } from '../interfaces/logger.interface.js';
+export interface LoggerOptions {
+    instance?: ILogger;
+}
+export declare class Logger implements ILogger {
+    protected _instance: ILogger;
+    constructor(options?: LoggerOptions);
+    info(message: any, ...optionalParams: any[]): void;
+    error(message: any, ...optionalParams: any[]): void;
+    fatal(message: any, ...optionalParams: any[]): void;
+    warn(message: any, ...optionalParams: any[]): void;
+    debug(message: any, ...optionalParams: any[]): void;
+    verbose(message: any, ...optionalParams: any[]): void;
+}

package/types/augmentation/collection.augmentation.d.ts

@@ -0,0 +1,112 @@
+import type { PartialOutput } from '@opra/common';
+import type { OperationContext } from '../adapter/operation-context.js';
+import type { Request as _Request } from '../adapter/request.js';
+declare module "@opra/common" {
+    namespace Collection {
+        namespace Create {
+            interface Request extends _Request {
+                operation: 'create';
+                data: any;
+                params: {
+                    pick?: string[];
+                    omit?: string[];
+                    include?: string[];
+                };
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+        namespace Delete {
+            interface Request extends _Request {
+                operation: 'delete';
+                key: any;
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+        namespace DeleteMany {
+            interface Request extends _Request {
+                operation: 'deleteMany';
+                params: {
+                    filter?: any;
+                };
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+        namespace FindMany {
+            interface Request extends _Request {
+                operation: 'findMany';
+                params: {
+                    filter?: any;
+                    pick?: string[];
+                    omit?: string[];
+                    include?: string[];
+                    sort?: string[];
+                    limit?: number;
+                    skip?: number;
+                    distinct?: boolean;
+                    count?: boolean;
+                };
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+        namespace Get {
+            interface Request extends _Request {
+                operation: 'get';
+                key: any;
+                params: {
+                    pick?: string[];
+                    omit?: string[];
+                    include?: string[];
+                };
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+        namespace Update {
+            interface Request extends _Request {
+                operation: 'update';
+                key: any;
+                data: any;
+                params: {
+                    pick?: string[];
+                    omit?: string[];
+                    include?: string[];
+                };
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+        namespace UpdateMany {
+            interface Request extends _Request {
+                operation: 'updateMany';
+                data: any;
+                params: {
+                    filter?: any;
+                };
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+    }
+    interface CollectionResource<T> {
+        create?(context: Collection.Create.Context): Promise<PartialOutput<T>>;
+        delete?(context: Collection.Delete.Context): Promise<number> | undefined;
+        deleteMany?(context: Collection.DeleteMany.Context): Promise<number> | undefined;
+        findMany?(context: Collection.FindMany.Context): Promise<PartialOutput<T>[] | undefined>;
+        get?(context: Collection.Get.Context): Promise<PartialOutput<T> | undefined>;
+        update?(context: Collection.Update.Context): Promise<PartialOutput<T> | undefined>;
+        updateMany?(context: Collection.UpdateMany.Context): Promise<number> | undefined;
+        onInit?(): Promise<void>;
+        onShutdown?(): Promise<void>;
+    }
+}

package/types/augmentation/singleton.augmentation.d.ts

@@ -0,0 +1,64 @@
+import type { PartialOutput } from '@opra/common';
+import type { OperationContext } from '../adapter/operation-context.js';
+import type { Request as _Request } from '../adapter/request.js';
+declare module "@opra/common" {
+    namespace Singleton {
+        namespace Create {
+            interface Request extends _Request {
+                operation: 'create';
+                data: any;
+                params: {
+                    pick?: string[];
+                    omit?: string[];
+                    include?: string[];
+                };
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+        namespace Delete {
+            interface Request extends _Request {
+                operation: 'delete';
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+        namespace Get {
+            interface Request extends _Request {
+                operation: 'get';
+                params: {
+                    pick?: string[];
+                    omit?: string[];
+                    include?: string[];
+                };
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+        namespace Update {
+            interface Request extends _Request {
+                operation: 'update';
+                data: any;
+                params: {
+                    pick?: string[];
+                    omit?: string[];
+                    include?: string[];
+                };
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+    }
+    interface SingletonResource<T> {
+        create?(context: Singleton.Create.Context): Promise<PartialOutput<T>>;
+        delete?(context: Singleton.Delete.Context): Promise<number> | undefined;
+        get?(context: Singleton.Get.Context): Promise<PartialOutput<T> | undefined>;
+        update?(context: Singleton.Update.Context): Promise<PartialOutput<T> | undefined>;
+        onInit?(): Promise<void>;
+        onShutdown?(): Promise<void>;
+    }
+}

package/types/augmentation/storage.augmentation.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Readable } from 'stream';
+import type { MultipartIterator } from '../adapter/http/helpers/multipart-helper';
+import type { OperationContext } from '../adapter/operation-context.js';
+import type { Request as _Request } from '../adapter/request.js';
+declare module "@opra/common" {
+    namespace Storage {
+        namespace Delete {
+            interface Request extends _Request {
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+        namespace Get {
+            interface Request extends _Request {
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+        namespace Post {
+            interface Request extends _Request {
+                parts: MultipartIterator;
+            }
+            interface Context extends OperationContext {
+                request: Request;
+            }
+        }
+    }
+    interface StorageResource {
+        delete?(context: Storage.Delete.Context): Promise<number | undefined>;
+        get?(context: Storage.Get.Context): Promise<Buffer | Readable | undefined>;
+        post?(context: Storage.Post.Context): Promise<void>;
+        onInit?(): Promise<void>;
+        onShutdown?(): Promise<void>;
+    }
+}

package/types/index.d.ts

@@ -1,15 +1,21 @@
 import "reflect-metadata";
 import './augmentation/resource.augmentation.js';
+import './augmentation/collection.augmentation.js';
+import './augmentation/singleton.augmentation.js';
+import './augmentation/storage.augmentation.js';
 export * from './types.js';
-export * from './adapter/adapter.js';
+export * from './adapter/execution-context.js';
+export * from './adapter/operation-context.js';
+export * from './adapter/platform-adapter.js';
+export * from './adapter/request.js';
+export * from './adapter/response.js';
 export * from './adapter/http/express-adapter.js';
 export * from './adapter/http/http-adapter.js';
-export * from './adapter/http/impl/http-server-request.js';
-export * from './adapter/http/impl/http-server-response.js';
-export * from './adapter/http/impl/http-incoming-message-host.js';
-export * from './adapter/http/impl/http-outgoing-message-host.js';
-export * from './adapter/interfaces/request-context.interface.js';
+export * from './adapter/http/impl/http-incoming-message.host.js';
+export * from './adapter/http/impl/http-outgoing-message.host.js';
+export * from './adapter/http/http-server-request.js';
+export * from './adapter/http/http-server-response.js';
 export * from './adapter/interfaces/logger.interface.js';
-export * from './adapter/interfaces/request.interface.js';
-export * from './adapter/interfaces/response.interface.js';
-export * from './shared/collection-resource-base.js';
+export * from './adapter/interfaces/request-handler.interface.js';
+export * from './adapter/services/logger.js';
+export * from './adapter/http/helpers/multipart-helper.js';

package/cjs/adapter/adapter.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraAdapter = void 0;
-const tslib_1 = require("tslib");
-const path_1 = tslib_1.__importDefault(require("path"));
-const strict_typed_events_1 = require("strict-typed-events");
-const common_1 = require("@opra/common");
-const metadata_resource_js_1 = require("./internal/metadata.resource.js");
-/**
- * @class OpraAdapter
- */
-class OpraAdapter extends strict_typed_events_1.AsyncEventEmitter {
-    constructor(api) {
-        super();
-        this.api = api;
-    }
-    /**
-     * Initializes the adapter
-     * @param options
-     * @protected
-     */
-    async init(options) {
-        this.logger = options?.logger;
-        if (options?.i18n instanceof common_1.I18n)
-            this.i18n = options.i18n;
-        else if (typeof options?.i18n === 'function')
-            this.i18n = await options.i18n();
-        else
-            this.i18n = await this._createI18n(options?.i18n);
-        this.i18n = this.i18n || common_1.I18n.defaultInstance;
-        if (!this.i18n.isInitialized)
-            await this.i18n.init();
-        if (options?.onRequest)
-            this.on('request', options.onRequest);
-        this._apiRoot = await common_1.DocumentFactory.createDocument({
-            version: common_1.OpraSchema.SpecVersion,
-            info: {
-                version: common_1.OpraSchema.SpecVersion,
-                title: 'Internal resources',
-            },
-            references: { 'api': this.api },
-            resources: [new metadata_resource_js_1.MetadataResource(this.api)]
-        });
-        const promises = [];
-        for (const r of this.api.resources.values()) {
-            const onInit = r.onInit;
-            if (onInit)
-                promises.push((async () => onInit.call(r.controller, r))());
-        }
-        await Promise.all(promises);
-    }
-    /**
-     * Calls shutDown hook for all resources
-     */
-    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);
-    }
-    async executeRequest(context) {
-        await this.emitAsync('request', context);
-        const { request, response } = context;
-        const { resource, operation } = request;
-        if (resource instanceof common_1.Collection || resource instanceof common_1.Singleton) {
-            const endpoint = resource.operations[operation];
-            if (!endpoint?.handler)
-                throw new common_1.ForbiddenError({
-                    message: (0, common_1.translate)('RESOLVER_FORBIDDEN', { operation }, `The resource endpoint does not accept '{{operation}}' operations`),
-                    severity: 'error',
-                    code: 'RESOLVER_FORBIDDEN'
-                });
-            const value = await endpoint.handler(context);
-            // if (value == null)
-            if (value != null)
-                response.value = value;
-            const { crud, many } = request;
-            if (crud === 'delete' || (crud === 'update' && many)) {
-                let affected = 0;
-                if (typeof response.value === 'number')
-                    affected = response.value;
-                if (typeof response.value === 'boolean')
-                    affected = response.value ? 1 : 0;
-                if (typeof response.value === 'object')
-                    affected = response.value.affectedRows || response.value.affected;
-                response.value = {
-                    operation: request.crud,
-                    affected
-                };
-            }
-            else if (response.value != null) {
-                if (!request.many)
-                    response.value = Array.isArray(response.value) ? response.value[0] : response.value;
-                else
-                    response.value = Array.isArray(response.value) ? response.value : [response.value];
-            }
-            if ((request.operation === 'get' || request.operation === 'update') && response.value == null)
-                throw new common_1.ResourceNotFoundError(resource.name, request.args.key);
-        }
-    }
-    async _createI18n(options) {
-        const opts = {
-            ...options,
-        };
-        delete opts.resourceDirs;
-        const instance = common_1.I18n.createInstance(opts);
-        await instance.init();
-        await instance.loadResourceDir(path_1.default.resolve((0, common_1.getStackFileName)(), '../../../i18n'));
-        if (options?.resourceDirs)
-            for (const dir of options.resourceDirs)
-                await instance.loadResourceDir(dir);
-        return instance;
-    }
-}
-exports.OpraAdapter = OpraAdapter;