@tstdl/base 0.92.122 → 0.92.124

package/queue/postgres/queue.js

@@ -34,12 +34,12 @@ let PostgresQueue = class PostgresQueue extends Queue {
         tries: 0,
         enqueueTimestamp: TRANSACTION_TIMESTAMP,
         lastDequeueTimestamp: null,
-        data: sql `excluded.data`
+        data: sql `excluded.data`,
     };
     #dequeueQuery = and(eq(job.queue, this.#queueName), lt(job.tries, this.maxTries), or(isSqlNull(job.lastDequeueTimestamp), lte(sql `${job.lastDequeueTimestamp} + ${interval(this.processTimeout, 'milliseconds')}`, TRANSACTION_TIMESTAMP)));
     #dequeueUpdate = {
         tries: sql `${job.tries} + 1`,
-        lastDequeueTimestamp: TRANSACTION_TIMESTAMP
+        lastDequeueTimestamp: TRANSACTION_TIMESTAMP,
     };
     async enqueue(data, options) {
         const jobs = await this.enqueueMany([{ data, tag: options?.tag, priority: options?.priority }], { uniqueTag: options?.uniqueTag, returnJobs: true });
@@ -53,7 +53,7 @@ let PostgresQueue = class PostgresQueue extends Queue {
             tries: 0,
             enqueueTimestamp: TRANSACTION_TIMESTAMP,
             lastDequeueTimestamp: null,
-            data: item.data
+            data: item.data,
         }));
         const update = (options?.uniqueTag == UniqueTagStrategy.TakeNew)
             ? this.#takeNewUpdate
@@ -157,8 +157,8 @@ PostgresQueue = __decorate([
         argumentIdentityProvider: JSON.stringify,
         providers: [
             provide(EntityRepositoryConfig, { useValue: { schema: 'queue' } }),
-            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresQueueModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) })
-        ]
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresQueueModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) }),
+        ],
     })
 ], PostgresQueue);
 export { PostgresQueue };

package/queue/queue.js

@@ -1,14 +1,14 @@
+import { defineEnum } from '../enumeration/enumeration.js';
 import { millisecondsPerMinute } from '../utils/units.js';
 import { QueueEnqueueBatch } from './enqueue-batch.js';
 export const defaultJobPriority = 1000;
-export var UniqueTagStrategy;
-(function (UniqueTagStrategy) {
-    UniqueTagStrategy[UniqueTagStrategy["KeepOld"] = 0] = "KeepOld";
-    UniqueTagStrategy[UniqueTagStrategy["TakeNew"] = 1] = "TakeNew";
-})(UniqueTagStrategy || (UniqueTagStrategy = {}));
+export const UniqueTagStrategy = defineEnum('UniqueTagStrategy', {
+    KeepOld: 0,
+    TakeNew: 1,
+});
 export const defaultQueueConfig = {
     processTimeout: millisecondsPerMinute,
-    maxTries: 3
+    maxTries: 3,
 };
 export class Queue {
     batch() {

package/schema/schemas/one-or-many.js

@@ -10,7 +10,7 @@ export class OneOrManySchema extends Schema {
     constructor(schema, options) {
         super(options);
         const oneSchema = schemaTestableToSchema(schema);
-        this.schema = union(oneSchema, array(oneSchema));
+        this.schema = union(oneSchema, array(oneSchema, { minimum: options?.minimum, maximum: options?.maximum }));
         lazyProperty(this, 'name', () => `OneOrMany[${oneSchema.name}]`);
     }
     _test(value, path, options) {

package/search-index/elastic/model/index-mapping.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/naming-convention */
 import { mergeObjects } from '../../../utils/object/merge.js';
 export function mergeElasticSearchMappings(mappings) {
     return mergeObjects(mappings);

package/search-index/elastic/search-index.js

@@ -43,10 +43,10 @@ export class ElasticSearchIndex extends SearchIndex {
         await this.client.indices.close({ index: this.indexName });
         this.logger.info(`closed index ${this.indexName} for updates`);
         this.logger.info(`updating settings for index ${this.indexName}`);
-        await this.client.indices.putSettings({ index: this.indexName, body: this.indexSettings });
+        await this.client.indices.putSettings({ index: this.indexName, settings: this.indexSettings });
         this.logger.info(`updated settings for index ${this.indexName}`);
         this.logger.info(`updating mapping for index ${this.indexName}`);
-        await this.client.indices.putMapping({ index: this.indexName, body: this.indexMapping });
+        await this.client.indices.putMapping({ index: this.indexName, ...this.indexMapping });
         this.logger.info(`updated mapping for index ${this.indexName}`);
         this.logger.info(`reopening index ${this.indexName}`);
         await this.client.indices.open({ index: this.indexName });
@@ -82,7 +82,7 @@ export class ElasticSearchIndex extends SearchIndex {
     }
     async deleteByQuery(query) {
         const queryBody = convertQuery(query);
-        await this.client.deleteByQuery({ index: this.indexName, body: { query: queryBody } });
+        await this.client.deleteByQuery({ index: this.indexName, query: queryBody });
     }
     // eslint-disable-next-line max-statements
     async search(searchQueryOrCursor, options) {

package/types/ai/ai-file.service.d.ts

@@ -0,0 +1,27 @@
+import '../../polyfills.js';
+import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import type { AiServiceOptions } from './ai.service.js';
+import type { FileContentPart, FileInput } from './types.js';
+export type AiFileServiceOptions = Pick<AiServiceOptions, 'apiKey' | 'keyFile' | 'vertex'>;
+export type AiFileServiceArgument = AiFileServiceOptions;
+type File = {
+    id: string;
+    name: string;
+    uri: string;
+    mimeType: string;
+};
+export declare class AiFileService implements Resolvable<AiFileServiceArgument> {
+    #private;
+    readonly [resolveArgumentType]: AiFileServiceArgument;
+    processFile(fileInput: FileInput): Promise<FileContentPart>;
+    processFiles(fileInputs: FileInput[]): Promise<FileContentPart[]>;
+    getFileById(id: string): File | undefined;
+    getFileByUri(uri: string): File | undefined;
+    private getFile;
+    private getFiles;
+    private uploadFile;
+    private getBucket;
+    private waitForFileActive;
+    private waitForFilesActive;
+}
+export {};

package/types/ai/ai-session.d.ts

@@ -0,0 +1,11 @@
+import type { OneOrMany } from '../../types.js';
+import type { AiService, CallFunctionsOptions, SpecializedGenerationResult } from './ai.service.js';
+import type { Content, GenerationRequest, GenerationResult, SchemaFunctionDeclarations, SchemaFunctionDeclarationsResult } from './types.js';
+export declare class AiSession {
+    #private;
+    readonly contents: Content[];
+    constructor(aiService: AiService);
+    addContent(content: OneOrMany<Content>): void;
+    callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
+    generate(request: GenerationRequest): Promise<GenerationResult>;
+}

package/types/ai/ai.service.d.ts

@@ -0,0 +1,60 @@
+import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import { type SchemaTestable } from '../../schema/index.js';
+import type { Enumeration as EnumerationType, EnumerationValue } from '../../types.js';
+import { AiSession } from './ai-session.js';
+import { type AiModel, type FileContentPart, type FileInput, type FunctionResultContentPart, type GenerationOptions, type GenerationRequest, type GenerationResult, type SchemaFunctionDeclarations, type SchemaFunctionDeclarationsResult } from './types.js';
+export type SpecializedGenerationResult<T> = {
+    result: T;
+    raw: GenerationResult;
+};
+export type SpecializedGenerationResultGenerator<T> = AsyncGenerator<T> & {
+    raw: Promise<GenerationResult>;
+};
+export declare class AiServiceOptions {
+    apiKey?: string;
+    keyFile?: string;
+    vertex?: {
+        project: string;
+        location: string;
+        bucket?: string;
+    };
+    defaultModel?: AiModel;
+}
+export type AiServiceArgument = AiServiceOptions;
+export type ClassificationResult<T extends EnumerationType> = {
+    types: {
+        type: EnumerationValue<T>;
+        confidence: 'high' | 'medium' | 'low';
+    }[] | null;
+};
+export type AnalyzeContentResult<T extends EnumerationType> = {
+    content: string[];
+    documentTypes: ClassificationResult<T>[];
+    tags: string[];
+};
+export type CallFunctionsOptions<T extends SchemaFunctionDeclarations> = Pick<GenerationRequest, 'contents' | 'model' | 'systemInstruction' | 'functionCallingMode'> & GenerationOptions & {
+    functions: T;
+};
+export declare class AiService implements Resolvable<AiServiceArgument> {
+    #private;
+    readonly defaultModel: AiModel;
+    readonly [resolveArgumentType]: AiServiceArgument;
+    createSession(): AiSession;
+    processFile(fileInput: FileInput): Promise<FileContentPart>;
+    processFiles(fileInputs: FileInput[]): Promise<FileContentPart[]>;
+    getFileById(id: string): FileContentPart;
+    callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]> & {
+        getFunctionResultContentParts: () => FunctionResultContentPart[];
+    }>;
+    callFunctionsStream<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): SpecializedGenerationResultGenerator<SchemaFunctionDeclarationsResult<T>>;
+    generate<S>(request: GenerationRequest<S>): Promise<GenerationResult<S>>;
+    generateStream<S>(request: GenerationRequest<S>): AsyncGenerator<GenerationResult<S>>;
+    private _callFunctionsStream;
+    private getModelOutputTokenLimit;
+    private _getModelOutputTokenLimit;
+    private convertContents;
+    private convertContent;
+    private convertFunctions;
+    private convertGoogleContent;
+}
+export declare function mergeGenerationStreamItems<S>(items: GenerationResult<S>[], schema?: SchemaTestable<S>): GenerationResult<S>;

package/types/ai/functions.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionDeclaration } from '@google/genai';
+import type { AbstractConstructor } from '../../types.js';
+export declare function getFunctionDeclarations(type: AbstractConstructor): FunctionDeclaration[];

package/types/ai/types.d.ts

@@ -0,0 +1,91 @@
+import type { LiteralUnion } from 'type-fest';
+import type { ObjectSchema, SchemaOutput, SchemaTestable } from '../../schema/index.js';
+import type { Record, UndefinableJsonObject } from '../../types.js';
+import type { ResolvedValueOrProvider, ValueOrAsyncProvider } from '../../utils/value-or-provider.js';
+export type FileInput = {
+    path: string;
+    mimeType: string;
+} | Blob;
+export type SchemaFunctionDeclarations = Record<string, SchemaFunctionDeclaration<any>>;
+export type SchemaFunctionDeclarationWithoutHandler<T extends Record = Record> = {
+    description: string;
+    parameters?: ValueOrAsyncProvider<ObjectSchema<T>>;
+    enabled?: ValueOrAsyncProvider<boolean>;
+};
+export type SchemaFunctionDeclarationWithHandler<T extends Record = Record, R = unknown> = SchemaFunctionDeclarationWithoutHandler<T> & {
+    handler: (parameters: T) => R | Promise<R>;
+};
+export type SchemaFunctionDeclaration<T extends Record = Record, R = unknown> = SchemaFunctionDeclarationWithoutHandler<T> | SchemaFunctionDeclarationWithHandler<T, R>;
+export type SchemaFunctionDeclarationHandlerResult<T extends SchemaFunctionDeclaration> = T extends SchemaFunctionDeclarationWithHandler<any, infer R> ? R : never;
+export type SchemaFunctionDeclarationsResult<T extends SchemaFunctionDeclarations = SchemaFunctionDeclarations> = {
+    [P in keyof T]: {
+        functionName: P;
+        parameters: SchemaOutput<NonNullable<ResolvedValueOrProvider<T[P]['parameters']>>>;
+        handlerResult: SchemaFunctionDeclarationHandlerResult<T[P]>;
+        getFunctionResultContentPart: () => FunctionResultContentPart;
+    };
+}[keyof T];
+export type ContentRole = 'user' | 'model';
+export type TextContentPart = {
+    text: string;
+};
+export type FileContentPart = {
+    file: string;
+};
+export type FunctionCall = {
+    name: string;
+    parameters: UndefinableJsonObject;
+};
+export type FunctionCallContentPart = {
+    functionCall: FunctionCall;
+};
+export type FunctionResult = {
+    name: string;
+    value: UndefinableJsonObject;
+};
+export type FunctionResultContentPart = {
+    functionResult: FunctionResult;
+};
+export type ContentPart = TextContentPart | FileContentPart | FunctionCallContentPart | FunctionResultContentPart;
+export type Content = {
+    role: ContentRole;
+    parts: readonly ContentPart[];
+};
+export type FunctionCallingMode = 'auto' | 'force' | 'none';
+export type FinishReason = 'stop' | 'maxTokens' | 'unknown';
+export type AiModel = LiteralUnion<'gemini-2.5-pro-exp-03-25' | 'gemini-2.5-flash-exp-04-17' | 'gemini-2.0-flash' | 'gemini-2.0-flash-lite', string>;
+export type GenerationOptions = {
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    thinkingBudget?: number;
+};
+export type GenerationRequest<S = unknown> = {
+    model?: AiModel;
+    systemInstruction?: string;
+    contents: Content | readonly Content[];
+    functions?: SchemaFunctionDeclarations;
+    functionCallingMode?: FunctionCallingMode;
+    generationSchema?: SchemaTestable<S>;
+    generationOptions?: GenerationOptions;
+};
+export type GenerationUsage = {
+    iterations: number;
+    prompt: number;
+    output: number;
+    total: number;
+};
+export type GenerationResult<S = unknown> = {
+    content: Content;
+    text: string | null;
+    json: S;
+    functionCalls: FunctionCall[];
+    finishReason: FinishReason;
+    usage: GenerationUsage;
+};
+export declare function defineFunctions<T extends SchemaFunctionDeclarations>(declarations: T): T;
+export declare function defineFunction<P extends Record, T extends SchemaFunctionDeclaration<P>>(declaration: T & Pick<SchemaFunctionDeclaration<P>, 'parameters'>): T;
+export declare function isSchemaFunctionDeclarationWithHandler(declaration: SchemaFunctionDeclaration): declaration is SchemaFunctionDeclarationWithHandler;

package/types/api/client/client.d.ts

@@ -0,0 +1,23 @@
+import { HttpClient, type HttpClientOptions } from '../../../http/client/index.js';
+import { type Resolvable } from '../../../injector/interfaces.js';
+import type { Type } from '../../../types.js';
+import { type ApiClientImplementation, type ApiDefinition, type ApiEndpointDefinition } from '../types.js';
+export type ApiClient<T extends ApiDefinition> = Type<ApiClientImplementation<T> & Resolvable<HttpClient | HttpClientOptions>, [httpClientOrOptions?: HttpClient | HttpClientOptions]>;
+export type ClientOptions = {
+    /**
+     * Url prefix
+     * @default `api/`
+     */
+    prefix?: string | null;
+    defaultHttpClientOptions?: HttpClientOptions | null;
+};
+export type ApiClientHttpRequestContext = {
+    endpoint: ApiEndpointDefinition;
+};
+export declare const httpClientSymbol: unique symbol;
+export declare const apiDefinitionSymbol: unique symbol;
+export declare const defaultOptions: ClientOptions;
+export declare function setDefaultApiClientOptions(options: ClientOptions): void;
+export declare function compileClient<T extends ApiDefinition>(definition: T, options?: ClientOptions): ApiClient<T>;
+export declare function getHttpClientOfApiClient(apiClient: any): HttpClient;
+export declare function getApiDefinitionOfApiClient(apiClient: any): ApiDefinition;

package/types/api/default-error-handlers.d.ts

@@ -0,0 +1,14 @@
+import { SchemaError } from '../../schema/index.js';
+import type { OneOrMany } from '../../types.js';
+export type SerializedSchemaError = {
+    path: string;
+    details?: any;
+    inner?: OneOrMany<SerializedInnerSchemaError>;
+};
+export type SerializedInnerSchemaError = SerializedSchemaError & {
+    message: string;
+};
+export declare function serializeSchemaError(error: SchemaError): SerializedSchemaError;
+export declare function serializeInnerSchemaError(error: SchemaError): SerializedInnerSchemaError;
+export declare function deserializeSchemaError(message: string, data: SerializedSchemaError): SchemaError;
+export declare function deserializeInnerSchemaError(data: SerializedInnerSchemaError): SchemaError;

package/types/api/server/api-controller.d.ts

@@ -0,0 +1,11 @@
+import { type InjectableOptionsWithoutLifecycle } from '../../../injector/decorators.js';
+import type { Constructor, Type } from '../../../types.js';
+import type { ApiController, ApiDefinition } from '../types.js';
+type ApiDefinitionProvider = () => ApiDefinition;
+export declare const apiControllerDefinition: unique symbol;
+export declare function getApiControllerDefinition(controller: Type | ApiController): ApiDefinition;
+export declare function isApiController(controller: Type): boolean;
+export declare function ensureApiController(controller: Type): void;
+export declare function apiController<T = Type<ApiController>, A = any>(definition: ApiDefinition | ApiDefinitionProvider, injectableOptions?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+export declare function implementApi<T extends ApiDefinition>(definition: T, implementation: ApiController<T>): Constructor<ApiController<T>>;
+export {};

package/types/api/server/error-handler.d.ts

@@ -0,0 +1,4 @@
+import type { HttpServerResponse } from '../../../http/server/index.js';
+import type { Logger } from '../../../logger/index.js';
+import type { Type } from '../../../types.js';
+export declare function handleApiError(error: unknown, response: HttpServerResponse, supressedErrors: Set<Type<Error>>, logger: Logger): HttpServerResponse;

package/types/api/server/gateway.d.ts

@@ -0,0 +1,77 @@
+import 'urlpattern-polyfill';
+import type { HttpServerRequestContext } from '../../../http/server/http-server.js';
+import { HttpServerResponse, type HttpServerRequest } from '../../../http/server/index.js';
+import { resolveArgumentType, type Resolvable } from '../../../injector/index.js';
+import { Logger } from '../../../logger/index.js';
+import type { Type } from '../../../types.js';
+import { type AsyncMiddleware, type AsyncMiddlewareNext } from '../../../utils/middleware.js';
+import { type ApiController, type ApiDefinition, type ApiEndpointDefinition, type ApiEndpointMethod, type ApiEndpointServerImplementation } from '../types.js';
+import { ApiRequestTokenProvider } from './api-request-token.provider.js';
+import type { CorsMiddlewareOptions } from './middlewares/cors.middleware.js';
+export type ApiGatewayMiddlewareContext = {
+    readonly api: ApiItem;
+    /** can be undefined if used before allowedMethods middleware */
+    readonly endpoint: GatewayEndpoint;
+    readonly resourcePatternResult: URLPatternResult;
+    readonly request: HttpServerRequest;
+    readonly response: HttpServerResponse;
+};
+export type ApiGatewayMiddlewareNext = AsyncMiddlewareNext;
+export type ApiGatewayMiddleware = AsyncMiddleware<ApiGatewayMiddlewareContext>;
+export declare abstract class ApiGatewayOptions {
+    /**
+     * Api prefix. Pass `null` to disable prefix.
+     * @default api
+     */
+    prefix?: string | null;
+    /** Initial middlewares */
+    middlewares?: ApiGatewayMiddleware[];
+    /** Errors to supress in log output */
+    supressedErrors?: Type<Error>[];
+    /** Cors middleware options */
+    cors?: CorsMiddlewareOptions;
+    /**
+     * Maximum size of request body. Useful to prevent harmful requests.
+     * @default 10 MB
+     */
+    defaultMaxBytes?: number;
+}
+export type GatewayEndpoint = {
+    definition: ApiEndpointDefinition;
+    implementation: ApiEndpointServerImplementation;
+};
+export type ApiItem = {
+    resource: string;
+    pattern: URLPattern;
+    endpoints: Map<ApiEndpointMethod, GatewayEndpoint>;
+};
+export type EndpointMetadataBodyType = 'none' | 'text' | 'json' | 'buffer' | 'stream';
+export type ApiGatewayArgument = ApiGatewayOptions;
+export type ApiMetadata = {
+    api: ApiItem;
+    patternResult: URLPatternResult;
+};
+/**
+ * router for {@link ApiTransport} requests to {@link ApiImplementation}
+ * @todo error handling (standardized format, serialization etc.)
+ */
+export declare class ApiGateway implements Resolvable<ApiGatewayOptions> {
+    private readonly requestTokenProvider;
+    private readonly logger;
+    private readonly prefix;
+    private readonly apis;
+    private readonly middlewares;
+    private readonly supressedErrors;
+    private readonly catchErrorMiddleware;
+    private readonly options;
+    private composedMiddleware;
+    readonly [resolveArgumentType]: ApiGatewayOptions;
+    constructor(requestTokenProvider: ApiRequestTokenProvider, logger: Logger, options?: ApiGatewayOptions);
+    addMiddleware(middleware: ApiGatewayMiddleware): void;
+    supressErrors(...errorTypes: Type<Error>[]): void;
+    registerApi<T extends ApiDefinition>(definition: ApiDefinition, implementation: ApiController<T>): void;
+    handleHttpServerRequestContext({ request, respond, close }: HttpServerRequestContext): Promise<void>;
+    getApiMetadata(resource: URL): ApiMetadata;
+    private updateMiddleware;
+    private endpointMiddleware;
+}

package/types/api/server/middlewares/catch-error.middleware.d.ts

@@ -0,0 +1,4 @@
+import type { Logger } from '../../../../logger/index.js';
+import type { Type } from '../../../../types.js';
+import type { ApiGatewayMiddleware } from '../gateway.js';
+export declare function getCatchErrorMiddleware(supressedErrors: Set<Type<Error>>, logger: Logger): ApiGatewayMiddleware;

package/types/api/server/middlewares/cors.middleware.d.ts

@@ -0,0 +1,6 @@
+import type { ApiEndpointDefinitionCors } from '../../../../api/types.js';
+import type { ApiGatewayMiddleware } from '../gateway.js';
+export type CorsMiddlewareOptions = {
+    default?: ApiEndpointDefinitionCors;
+};
+export declare function corsMiddleware(options?: CorsMiddlewareOptions): ApiGatewayMiddleware;

package/types/api/server/module.d.ts

@@ -0,0 +1,10 @@
+import type { Type } from '../../../types.js';
+import { ApiRequestTokenProvider } from './api-request-token.provider.js';
+import type { ApiGatewayOptions } from './gateway.js';
+export type ApiModuleOptions = {
+    controllers: Type[];
+    requestTokenProvider?: Type<ApiRequestTokenProvider>;
+    gatewayOptions?: ApiGatewayOptions;
+};
+export declare const apiModuleOptions: ApiModuleOptions;
+export declare function configureApiServer(options: Partial<ApiModuleOptions>): void;

package/types/api/server/tokens.d.ts

@@ -0,0 +1,5 @@
+import type { ApiController } from '../types.js';
+import type { ApiModuleOptions } from './module.js';
+export declare const API_MODULE_OPTIONS: import("../../../injector/token.js").InjectionToken<ApiModuleOptions, never>;
+export declare const API_CONTROLLER: import("../../../injector/token.js").InjectionToken<ApiController, never>;
+export declare const API_CONTROLLERS: import("../../../injector/token.js").InjectionToken<ApiController[], never>;

package/types/api/types.d.ts

@@ -0,0 +1,123 @@
+import type { HttpServerRequest, HttpServerResponse } from '../../http/server/index.js';
+import type { HttpMethod } from '../../http/types.js';
+import type { SchemaOutput, SchemaTestable } from '../../schema/index.js';
+import type { ServerSentEventsSource } from '../../sse/server-sent-events-source.js';
+import type { ServerSentEvents } from '../../sse/server-sent-events.js';
+import type { NonUndefinable, OneOrMany, Record, ReturnTypeOrT } from '../../types.js';
+import { type ValueOrProvider } from '../../utils/value-or-provider.js';
+import type { ApiGatewayMiddlewareContext } from './server/index.js';
+export type ApiRegistrationOptions = {
+    name?: string;
+    prefix?: string;
+};
+export type ApiRegistration = {
+    target: object;
+    name: string;
+    path: string;
+    prefix: string;
+};
+export type EndpointRegistrationOptions = {
+    path?: string;
+    description?: string;
+};
+export type ApiEndpointMethod = HttpMethod;
+export type ApiEndpointDefinitionParameters = SchemaTestable;
+export type ApiEndpointDefinitionBody = SchemaTestable | typeof String | typeof Uint8Array | typeof Blob | typeof ReadableStream;
+export type ApiEndpointDefinitionResult = SchemaTestable | typeof String | typeof Uint8Array | typeof Blob | typeof ReadableStream;
+export type ApiEndpointDataProvider<T> = T | ((request: HttpServerRequest, context: ApiGatewayMiddlewareContext) => T | Promise<T>);
+export type ApiEndpointDefinitionCors = {
+    accessControlAllowCredentials?: ApiEndpointDataProvider<boolean | undefined>;
+    accessControlAllowHeaders?: ApiEndpointDataProvider<OneOrMany<string> | undefined>;
+    accessControlAllowMethods?: ApiEndpointDataProvider<OneOrMany<HttpMethod> | undefined>;
+    accessControlAllowOrigin?: ApiEndpointDataProvider<string | undefined>;
+    autoAccessControlAllowOrigin?: ApiEndpointDataProvider<OneOrMany<string> | undefined>;
+    accessControlExposeHeaders?: ApiEndpointDataProvider<OneOrMany<string> | undefined>;
+    accessControlMaxAge?: ApiEndpointDataProvider<number | undefined>;
+};
+export type ApiEndpointDefinition = {
+    /**
+     * Http Method
+     * @default GET
+     */
+    method?: OneOrMany<ApiEndpointMethod>;
+    /** Endpoint prefix. Overwrites default from api and gateway. */
+    prefix?: string | null;
+    /** Root resource path. Overwrites default from {@link ApiDefinition}. */
+    rootResource?: string | null;
+    /**
+     * Sub resource in api
+     *
+     * results in
+     * ```ts
+     * ${endpoint.rootResource ?? api.ressource}/${endpoint.resource}
+     * ```
+     * @default name of endpoint property
+     */
+    resource?: string;
+    version?: OneOrMany<number | null>;
+    parameters?: ApiEndpointDefinitionParameters;
+    body?: ApiEndpointDefinitionBody;
+    result?: ApiEndpointDefinitionResult;
+    /** Maximum size of request body. Useful to prevent harmful requests. */
+    maxBytes?: number;
+    description?: string;
+    data?: Record;
+    /**
+     * If true, sets browsers fetch to { credentials: 'include' } and enables 'Access-Control-Allow-Credentials' header.
+     *
+     * @default false
+     */
+    credentials?: boolean;
+    cors?: ApiEndpointDefinitionCors;
+};
+export type ApiEndpointsDefinition = Record<string, ValueOrProvider<ApiEndpointDefinition>>;
+export type ApiDefinition<Resource extends string = string, Endpoints extends ApiEndpointsDefinition = ApiEndpointsDefinition> = {
+    /**
+     * Default root resource for endpoints.
+     */
+    resource: Resource;
+    /**
+     * Endpoint prefix. Overwrites default from gateway.
+     */
+    prefix?: string | null;
+    endpoints: Endpoints;
+};
+export type ApiEndpointKeys<T extends ApiDefinition> = keyof T['endpoints'];
+export type NormalizedApiEndpoints<T extends ApiDefinition['endpoints']> = {
+    [P in keyof T]: ReturnTypeOrT<T[P]>;
+};
+export type ApiEndpoint<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NormalizedApiEndpoints<T['endpoints']>[K];
+export type ApiEndpointParametersSchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['parameters']>;
+export type ApiEndpointBodySchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['body']>;
+export type ApiEndpointResultSchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['result']>;
+export type ApiBinaryType = typeof Uint8Array | typeof Blob | typeof ReadableStream<any>;
+export type ApiInputType<T extends SchemaTestable> = T extends ApiBinaryType ? InstanceType<ApiBinaryType> : T extends typeof ServerSentEvents ? ServerSentEventsSource : T extends SchemaTestable ? SchemaOutput<T> : never;
+export type ApiOutputType<T extends SchemaTestable> = T extends typeof ReadableStream ? ReadableStream<Uint8Array> : T extends SchemaTestable ? SchemaOutput<T> : never;
+export type ApiParameters<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointParametersSchema<T, K>>;
+export type ApiClientBody<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointBodySchema<T, K>>;
+export type ApiServerBody<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiOutputType<ApiEndpointBodySchema<T, K>>;
+export type ApiServerResult<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointResultSchema<T, K>> | HttpServerResponse;
+export type ApiClientResult<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiOutputType<ApiEndpointResultSchema<T, K>>;
+export type ApiRequestData<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> = {
+    parameters: ApiParameters<T, K>;
+    body: ApiServerBody<T, K>;
+    request: HttpServerRequest;
+};
+export type ApiRequestContext<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> = ApiRequestData<T, K> & {
+    getToken<Token>(): Promise<Token>;
+};
+export type ApiEndpointServerImplementation<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> = (context: ApiRequestContext<T, K>) => ApiServerResult<T, K> | Promise<ApiServerResult<T, K>>;
+export type ApiEndpointClientImplementation<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> = ApiClientBody<T, K> extends never ? ApiParameters<T, K> extends never ? () => Promise<ApiClientResult<T, K>> : (parameters: ApiParameters<T, K>) => Promise<ApiClientResult<T, K>> : (parameters: ApiParameters<T, K> extends never ? undefined | Record<never, never> : ApiParameters<T, K>, body: ApiClientBody<T, K>) => Promise<ApiClientResult<T, K>>;
+export type ApiController<T extends ApiDefinition = any> = {
+    [P in ApiEndpointKeys<T>]: ApiEndpointServerImplementation<T, P>;
+};
+export type ApiClientImplementation<T extends ApiDefinition = any> = {
+    [P in ApiEndpointKeys<T>]: ApiEndpointClientImplementation<T, P>;
+} & {
+    getEndpointResource<E extends ApiEndpointKeys<T>>(endpoint: E, parameters?: ApiParameters<T, E>): string;
+    getEndpointUrl<E extends ApiEndpointKeys<T>>(endpoint: E, parameters?: ApiParameters<T, E>): string;
+};
+export declare function defineApi<T extends ApiDefinition>(definition: T): T;
+export declare function resolveApiEndpointDataProvider<T>(request: HttpServerRequest, context: ApiGatewayMiddlewareContext, provider: ApiEndpointDataProvider<T>): Promise<T>;
+export declare function normalizedApiDefinitionEndpoints<T extends ApiDefinition['endpoints']>(apiDefinitionEndpoints: T): NormalizedApiEndpoints<T>;
+export declare function normalizedApiDefinitionEndpointsEntries<T extends ApiDefinition['endpoints']>(apiDefinition: T): [keyof T, ApiEndpointDefinition][];

package/types/application/application.d.ts

@@ -0,0 +1,34 @@
+import type { CancellationSignal } from '../../cancellation/token.js';
+import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import type { LoggerArgument } from '../../logger/index.js';
+import type { Module } from '../../module/module.js';
+import type { FunctionModuleFunction } from '../../module/modules/function.module.js';
+import type { OneOrMany, Type } from '../../types.js';
+export type BootstrapFn = () => void | Promise<void>;
+export type RunOptions = {
+    bootstrap?: OneOrMany<BootstrapFn>;
+};
+export type ApplicationArgument = LoggerArgument;
+export declare class Application implements Resolvable<ApplicationArgument> {
+    #private;
+    static _instance: Application | undefined;
+    private static get instance();
+    readonly [resolveArgumentType]: string;
+    get shutdownSignal(): CancellationSignal;
+    static get shutdownSignal(): CancellationSignal;
+    static registerModule(moduleType: Type<Module>): void;
+    static registerModuleFunction(fn: FunctionModuleFunction): void;
+    static run(...functionsAndModules: [RunOptions | OneOrMany<FunctionModuleFunction | Type<Module>>, ...OneOrMany<FunctionModuleFunction | Type<Module>>[]]): void;
+    static waitForShutdown(): Promise<void>;
+    static shutdown(): Promise<void>;
+    static requestShutdown(): void;
+    registerModule(moduleType: Module | Type<Module>): void;
+    registerModuleFunction(fn: FunctionModuleFunction): void;
+    run(...optionsFunctionsAndModules: [RunOptions | OneOrMany<FunctionModuleFunction | Type<Module>>, ...OneOrMany<FunctionModuleFunction | Type<Module>>[]]): void;
+    shutdown(): Promise<void>;
+    requestShutdown(): void;
+    waitForShutdown(): Promise<void>;
+    private _run;
+    private runModules;
+    private stopModules;
+}