@opra/core 0.21.0 → 0.23.0

package/types/adapter/http/{impl/http-server-request.d.ts → http-server-request.d.ts}

@@ -1,14 +1,15 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { Options as RangeParserOptions, Ranges as RangeParserRanges, Result as RangeParserResult } from 'range-parser';
-import stream from 'stream';
-import { HttpIncomingMessage, HttpIncomingMessageHost } from './http-incoming-message-host.js';
-import type { HttpServerResponse } from './http-server-response.js';
+import { OpraURL } from '@opra/common';
+import type { HttpServerResponse } from './http-server-response';
+import { HttpIncomingMessage, HttpIncomingMessageHost } from './impl/http-incoming-message.host.js';
 export declare namespace HttpServerRequest {
-    function create(instance?: HttpIncomingMessage | HttpIncomingMessageHost.Initiator | Buffer | stream.Readable): HttpServerRequest;
+    function from(instance: HttpIncomingMessage | HttpIncomingMessageHost.Initiator | string | Iterable<any> | AsyncIterable<any>): HttpServerRequest;
 }
 export interface HttpServerRequest extends HttpIncomingMessage {
     res: HttpServerResponse;
+    baseUrl: string;
+    originalUrl: string;
+    parsedUrl: OpraURL;
     body?: any;
     /**
      * Return the protocol string "http" or "https"

package/types/adapter/http/{impl/http-server-response.d.ts → http-server-response.d.ts}

@@ -1,7 +1,7 @@
-import { HttpOutgoingMessage, HttpOutgoingMessageHost } from './http-outgoing-message-host.js';
 import type { HttpServerRequest } from './http-server-request.js';
+import { HttpOutgoingMessage, HttpOutgoingMessageHost } from './impl/http-outgoing-message.host.js';
 export declare namespace HttpServerResponse {
-    function create(instance?: HttpOutgoingMessage | HttpOutgoingMessageHost.Initiator): HttpServerResponse;
+    function from(instance?: HttpOutgoingMessage | HttpOutgoingMessageHost.Initiator): HttpServerResponse;
 }
 export interface HttpServerResponse extends HttpOutgoingMessage {
     req?: HttpServerRequest;

package/types/adapter/http/impl/{http-incoming-message-host.d.ts → http-incoming-message.host.d.ts}

@@ -3,14 +3,14 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import http, { IncomingHttpHeaders } from 'http';
-import * as stream from 'stream';
-import { Readable } from 'stream';
+import { Duplex, Readable } from 'stream';
+import { HTTPParserJS } from '@browsery/http-parser';
 export declare const CRLF: Buffer;
 export declare const kHeaders: unique symbol;
 export declare const kHeadersDistinct: unique symbol;
 export declare const kTrailers: unique symbol;
 export declare const kTrailersDistinct: unique symbol;
-export interface HttpIncomingMessage extends Pick<http.IncomingMessage, 'httpVersion' | 'httpVersionMajor' | 'httpVersionMinor' | 'complete' | 'headers' | 'trailers' | 'rawHeaders' | 'rawTrailers' | 'method' | 'url'>, stream.Readable {
+export interface HttpIncomingMessage extends Pick<http.IncomingMessage, 'httpVersion' | 'httpVersionMajor' | 'httpVersionMinor' | 'complete' | 'headers' | 'trailers' | 'rawHeaders' | 'rawTrailers' | 'method' | 'url'>, Readable {
 }
 export declare namespace HttpIncomingMessageHost {
     interface Initiator {
@@ -25,25 +25,29 @@ export declare namespace HttpIncomingMessageHost {
         ips?: string[];
     }
 }
-export interface HttpIncomingMessageHost extends stream.Readable {
-}
 /**
  *
  * @class HttpIncomingMessageHost
  */
-export declare class HttpIncomingMessageHost implements HttpIncomingMessage {
+export declare class HttpIncomingMessageHost extends Duplex implements HttpIncomingMessage {
+    protected [kHeaders]?: IncomingHttpHeaders;
+    protected [kHeadersDistinct]?: NodeJS.Dict<string[]>;
+    protected [kTrailers]?: NodeJS.Dict<string>;
+    protected [kTrailersDistinct]?: NodeJS.Dict<string[]>;
+    protected _httpParser: HTTPParserJS | undefined;
+    protected _readStream?: Readable;
     httpVersionMajor: number;
     httpVersionMinor: number;
     method: string;
     url: string;
     rawHeaders: string[];
     rawTrailers: string[];
-    body?: any;
+    body?: Buffer;
     complete: boolean;
     ip?: string;
     ips?: string[];
     joinDuplicateHeaders: boolean;
-    constructor();
+    constructor(init?: HttpIncomingMessageHost.Initiator);
     get httpVersion(): string;
     get headers(): IncomingHttpHeaders;
     set headers(headers: IncomingHttpHeaders);
@@ -51,8 +55,8 @@ export declare class HttpIncomingMessageHost implements HttpIncomingMessage {
     get trailers(): NodeJS.Dict<string>;
     set trailers(trailers: NodeJS.Dict<string>);
     get trailersDistinct(): NodeJS.Dict<string[]>;
-    protected _readConfig(init: HttpIncomingMessageHost.Initiator): void;
-    protected _readBuffer(buf: Buffer | ArrayBuffer): void;
-    _readStream(readable: Readable): void;
-    static create(init?: HttpIncomingMessageHost.Initiator | Buffer | stream.Readable): HttpIncomingMessageHost;
+    _read(size: number): void;
+    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    static from(iterable: string | Iterable<any> | AsyncIterable<any> | HttpIncomingMessageHost.Initiator): HttpIncomingMessageHost;
+    static fromAsync(iterable: string | Iterable<any> | AsyncIterable<any> | HttpIncomingMessageHost.Initiator): Promise<HttpIncomingMessageHost>;
 }

package/types/adapter/http/impl/{http-outgoing-message-host.d.ts → http-outgoing-message.host.d.ts}

@@ -2,18 +2,17 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import http, { OutgoingHttpHeaders } from 'http';
-import * as stream from 'stream';
-import type { HttpIncomingMessage } from './http-incoming-message-host.js';
+import { Duplex, Writable } from 'stream';
+import type { HttpIncomingMessage } from './http-incoming-message.host';
 export declare const kOutHeaders: unique symbol;
 export declare const kOutTrailers: unique symbol;
-export declare const kErrored: unique symbol;
 declare global {
     interface Headers {
         keys(): IterableIterator<string>;
         entries(): IterableIterator<[string, any]>;
     }
 }
-export interface HttpOutgoingMessage extends Pick<http.ServerResponse, 'addTrailers' | 'getHeader' | 'getHeaders' | 'getHeaderNames' | 'removeHeader' | 'hasHeader' | 'headersSent' | 'statusCode' | 'statusMessage' | 'sendDate'>, stream.Writable {
+export interface HttpOutgoingMessage extends Pick<http.ServerResponse, 'addTrailers' | 'getHeader' | 'getHeaders' | 'getHeaderNames' | 'removeHeader' | 'hasHeader' | 'headersSent' | 'statusCode' | 'statusMessage' | 'sendDate'>, Writable {
     req?: HttpIncomingMessage;
     appendHeader(name: string, value: string | readonly string[]): this;
     setHeader(name: string, value: number | string | readonly string[]): this;
@@ -27,21 +26,19 @@ export declare namespace HttpOutgoingMessageHost {
         chunkedEncoding?: boolean;
         sendDate?: boolean;
         strictContentLength?: boolean;
-        body?: any;
+        body?: string | Iterable<any> | AsyncIterable<any> | Object;
     }
 }
-export interface HttpOutgoingMessageHost extends stream.Writable {
-}
 /**
  *
  * @class HttpOutgoingMessageHost
  */
-export declare class HttpOutgoingMessageHost {
-    protected _headersSent: boolean;
-    protected _closed: boolean;
-    protected [kErrored]: Error | null;
+export declare class HttpOutgoingMessageHost extends Duplex implements HttpOutgoingMessage {
     protected [kOutHeaders]: Record<string, any>;
     protected [kOutTrailers]: Record<string, any>;
+    protected _headersSent: boolean;
+    protected _httpVersionMajor?: number;
+    protected _httpVersionMinor?: number;
     finished: boolean;
     req?: HttpIncomingMessage;
     statusCode: number;
@@ -50,10 +47,10 @@ export declare class HttpOutgoingMessageHost {
     sendDate: boolean;
     strictContentLength: boolean;
     body?: any;
-    constructor();
+    constructor(init?: HttpOutgoingMessageHost.Initiator);
+    get httpVersionMajor(): number | undefined;
+    get httpVersionMinor(): number | undefined;
     get headersSent(): boolean;
-    get closed(): boolean;
-    get errored(): Error | null;
     appendHeader(name: string, value: number | string | readonly string[]): this;
     addTrailers(headers: OutgoingHttpHeaders | [string, string][] | readonly [string, string][]): void;
     setHeader(name: any, value: any): this;
@@ -67,6 +64,5 @@ export declare class HttpOutgoingMessageHost {
     end(cb?: () => void): this;
     end(chunk: any, cb?: () => void): this;
     end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
-    protected _readConfig(init: HttpOutgoingMessageHost.Initiator): void;
-    static create(init?: HttpOutgoingMessageHost.Initiator): HttpOutgoingMessageHost;
+    static from(init: HttpOutgoingMessageHost.Initiator): HttpOutgoingMessageHost;
 }

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

@@ -0,0 +1,24 @@
+import { Collection, OpraSchema, Singleton } from '@opra/common';
+import { ExecutionContext } from '../../execution-context.js';
+import { OperationContext } from '../../operation-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>;
+    executeOperation(context: OperationContext): Promise<void>;
+    sendResponse(context: OperationContext): Promise<void>;
+    parseCollectionRequest(resource: Collection, incoming: HttpServerRequest): Promise<Request>;
+    parseSingletonRequest(resource: Singleton, incoming: HttpServerRequest): Promise<Request>;
+    getBodyLoader(operation: OpraSchema.Collection.CreateOperation | OpraSchema.Collection.UpdateOperation | OpraSchema.Collection.UpdateManyOperation): BodyLoaderFunction;
+}
+export {};

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

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

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

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

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

@@ -1,8 +1,9 @@
 export interface ILogger {
-    log(message: any, ...optionalParams: any[]): any;
-    error(message: any, ...optionalParams: any[]): any;
-    fatal?(message: any, ...optionalParams: any[]): any;
-    warn(message: any, ...optionalParams: any[]): any;
-    debug?(message: any, ...optionalParams: any[]): any;
-    verbose?(message: any, ...optionalParams: any[]): any;
+    log?(message: any, ...optionalParams: any[]): void;
+    info?(message: any, ...optionalParams: any[]): void;
+    warn?(message: any, ...optionalParams: any[]): void;
+    error?(message: any, ...optionalParams: any[]): void;
+    fatal?(message: any, ...optionalParams: any[]): void;
+    debug?(message: any, ...optionalParams: any[]): void;
+    verbose?(message: any, ...optionalParams: any[]): void;
 }

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

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

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

@@ -0,0 +1,11 @@
+import type { ExecutionContext } from './execution-context';
+import type { Request } from './request';
+import type { Response } from './response';
+export interface OperationContext<TRequest extends Request = Request, TResponse extends Response = Response> extends ExecutionContext {
+    request: TRequest;
+    response: TResponse;
+    requestScope: Record<string | number | symbol, any>;
+}
+export declare namespace OperationContext {
+    function from<TRequest extends Request = Request, TResponse extends Response = Response>(executionContext: ExecutionContext, request: TRequest, response: TResponse): OperationContext;
+}

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>;
+    }
+}