awilixify 2.2.1 → 3.1.0

package/dist/lib/http/decorators.js

@@ -0,0 +1,151 @@
+import { createDecoratorStateUpdater } from "../decorators/decorator-state.js";
+import { HttpVerbs } from "./http-verbs.js";
+const { update, token } = createDecoratorStateUpdater("http-decorator-state", {
+    method: () => ({
+        paths: [],
+        beforeMiddleware: [],
+        afterMiddleware: [],
+        verbs: [],
+        schema: {},
+    }),
+    root: () => ({
+        paths: [],
+        beforeMiddleware: [],
+        afterMiddleware: [],
+    }),
+});
+export const HTTP_DECORATOR_STATE_TOKEN = token;
+function createRouteDecorator(httpVerb) {
+    return (path = "/") => (target, context) => {
+        update(context, {
+            method: (previous) => {
+                return {
+                    ...previous,
+                    verbs: uniq([...previous.verbs, httpVerb]),
+                    paths: uniq([...previous.paths, path]),
+                };
+            },
+        });
+        return target;
+    };
+}
+export const GET = createRouteDecorator(HttpVerbs.GET);
+export const POST = createRouteDecorator(HttpVerbs.POST);
+export const PUT = createRouteDecorator(HttpVerbs.PUT);
+export const DELETE = createRouteDecorator(HttpVerbs.DELETE);
+export const PATCH = createRouteDecorator(HttpVerbs.PATCH);
+export function controller(options) {
+    return (target, context) => {
+        if (!options)
+            return target;
+        update(context, {
+            root: (previous) => {
+                return {
+                    ...previous,
+                    paths: uniq([...previous.paths, ...normalizePaths(options)]),
+                };
+            },
+        });
+        return target;
+    };
+}
+export function before(middleware) {
+    return (target, context) => {
+        if (context.kind === "class") {
+            update(context, {
+                root: (previous) => {
+                    return {
+                        ...previous,
+                        beforeMiddleware: appendMiddleware(previous.beforeMiddleware, middleware),
+                    };
+                },
+            });
+            return target;
+        }
+        update(context, {
+            method: (previous) => {
+                return {
+                    ...previous,
+                    beforeMiddleware: appendMiddleware(previous.beforeMiddleware, middleware),
+                };
+            },
+        });
+        return target;
+    };
+}
+export function after(middleware) {
+    return (target, context) => {
+        if (context.kind === "class") {
+            update(context, {
+                root: (previous) => {
+                    return {
+                        ...previous,
+                        afterMiddleware: appendMiddleware(previous.afterMiddleware, middleware),
+                    };
+                },
+            });
+            return target;
+        }
+        update(context, {
+            method: (previous) => {
+                return {
+                    ...previous,
+                    afterMiddleware: appendMiddleware(previous.afterMiddleware, middleware),
+                };
+            },
+        });
+        return target;
+    };
+}
+export function schema(schema) {
+    return (target, context) => {
+        update(context, {
+            method: (previous) => {
+                return {
+                    ...previous,
+                    schema,
+                };
+            },
+        });
+        return target;
+    };
+}
+function uniq(items) {
+    const result = [];
+    for (const item of items) {
+        if (!result.includes(item))
+            result.push(item);
+    }
+    return result;
+}
+function normalizePaths(options) {
+    if (typeof options === "string")
+        return [options];
+    if (Array.isArray(options))
+        return options;
+    return Array.isArray(options.path) ? options.path : [options.path];
+}
+function appendMiddleware(target, incoming) {
+    return Array.isArray(incoming)
+        ? [...target, ...incoming]
+        : [...target, incoming];
+}
+export function rollUpHttpDecoratorState(root, method) {
+    return {
+        ...method,
+        paths: concatPaths(root.paths, method.paths),
+        beforeMiddleware: [...root.beforeMiddleware, ...method.beforeMiddleware],
+        afterMiddleware: [...method.afterMiddleware, ...root.afterMiddleware],
+    };
+}
+function concatPaths(rootPaths, methodPaths) {
+    if (rootPaths.length === 0)
+        return [...methodPaths];
+    const result = [];
+    rootPaths.forEach((rootPath) => {
+        methodPaths.forEach((methodPath) => {
+            result.push(rootPath + methodPath);
+        });
+    });
+    return result;
+}

package/dist/lib/http/exceptions.d.ts

@@ -0,0 +1,58 @@
+export declare enum HttpStatus {
+    OK = 200,
+    CREATED = 201,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    I_AM_A_TEAPOT = 418,
+    UNPROCESSABLE_ENTITY = 422,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505
+}
+export declare class HttpException<TMessage extends string, TStatus extends HttpStatus = HttpStatus> extends Error {
+    readonly message: TMessage;
+    readonly statusCode: TStatus;
+    readonly response?: (Record<string, any> | null) | undefined;
+    constructor(message: TMessage, statusCode: TStatus, response?: (Record<string, any> | null) | undefined);
+    getResponse(): {
+        message: TMessage;
+        statusCode: TStatus;
+        [key: string]: any;
+    };
+    getStatus(): TStatus;
+}
+export declare const httpException: {
+    badRequest: <M extends string = "Bad Request">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Bad Request" : M, HttpStatus.BAD_REQUEST>;
+    unauthorized: <M extends string = "Unauthorized">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Unauthorized" : M, HttpStatus.UNAUTHORIZED>;
+    forbidden: <M extends string = "Forbidden">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Forbidden" : M, HttpStatus.FORBIDDEN>;
+    notFound: <M extends string = "Not Found">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Not Found" : M, HttpStatus.NOT_FOUND>;
+    methodNotAllowed: <M extends string = "Method Not Allowed">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Method Not Allowed" : M, HttpStatus.METHOD_NOT_ALLOWED>;
+    notAcceptable: <M extends string = "Not Acceptable">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Not Acceptable" : M, HttpStatus.NOT_ACCEPTABLE>;
+    requestTimeout: <M extends string = "Request Timeout">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Request Timeout" : M, HttpStatus.REQUEST_TIMEOUT>;
+    conflict: <M extends string = "Conflict">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Conflict" : M, HttpStatus.CONFLICT>;
+    gone: <M extends string = "Gone">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Gone" : M, HttpStatus.GONE>;
+    preconditionFailed: <M extends string = "Precondition Failed">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Precondition Failed" : M, HttpStatus.PRECONDITION_FAILED>;
+    payloadTooLarge: <M extends string = "Payload Too Large">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Payload Too Large" : M, HttpStatus.PAYLOAD_TOO_LARGE>;
+    unsupportedMediaType: <M extends string = "Unsupported Media Type">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Unsupported Media Type" : M, HttpStatus.UNSUPPORTED_MEDIA_TYPE>;
+    imATeapot: <M extends string = "I'm a teapot">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "I'm a teapot" : M, HttpStatus.I_AM_A_TEAPOT>;
+    unprocessableEntity: <M extends string = "Unprocessable Entity">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Unprocessable Entity" : M, HttpStatus.UNPROCESSABLE_ENTITY>;
+    internalServerError: <M extends string = "Internal Server Error">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Internal Server Error" : M, HttpStatus.INTERNAL_SERVER_ERROR>;
+    notImplemented: <M extends string = "Not Implemented">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Not Implemented" : M, HttpStatus.NOT_IMPLEMENTED>;
+    badGateway: <M extends string = "Bad Gateway">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Bad Gateway" : M, HttpStatus.BAD_GATEWAY>;
+    serviceUnavailable: <M extends string = "Service Unavailable">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Service Unavailable" : M, HttpStatus.SERVICE_UNAVAILABLE>;
+    gatewayTimeout: <M extends string = "Gateway Timeout">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "Gateway Timeout" : M, HttpStatus.GATEWAY_TIMEOUT>;
+    httpVersionNotSupported: <M extends string = "HTTP Version Not Supported">(message?: M | undefined, response?: Record<string, any>) => HttpException<M extends undefined ? "HTTP Version Not Supported" : M, HttpStatus.HTTP_VERSION_NOT_SUPPORTED>;
+};

package/dist/lib/http/exceptions.js

@@ -0,0 +1,71 @@
+export var HttpStatus;
+(function (HttpStatus) {
+    HttpStatus[HttpStatus["OK"] = 200] = "OK";
+    HttpStatus[HttpStatus["CREATED"] = 201] = "CREATED";
+    HttpStatus[HttpStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpStatus[HttpStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpStatus[HttpStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HttpStatus[HttpStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpStatus[HttpStatus["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+    HttpStatus[HttpStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HttpStatus[HttpStatus["CONFLICT"] = 409] = "CONFLICT";
+    HttpStatus[HttpStatus["GONE"] = 410] = "GONE";
+    HttpStatus[HttpStatus["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+    HttpStatus[HttpStatus["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    HttpStatus[HttpStatus["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+    HttpStatus[HttpStatus["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+    HttpStatus[HttpStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+    HttpStatus[HttpStatus["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+})(HttpStatus || (HttpStatus = {}));
+export class HttpException extends Error {
+    message;
+    statusCode;
+    response;
+    constructor(message, statusCode, response) {
+        super(message);
+        this.message = message;
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+    getResponse() {
+        return {
+            message: this.message,
+            statusCode: this.statusCode,
+            ...this.response,
+        };
+    }
+    getStatus() {
+        return this.statusCode;
+    }
+}
+const createFactory = (defaultMessage, status) => (message, response) => new HttpException((message ?? defaultMessage), status, response);
+export const httpException = {
+    badRequest: createFactory("Bad Request", HttpStatus.BAD_REQUEST),
+    unauthorized: createFactory("Unauthorized", HttpStatus.UNAUTHORIZED),
+    forbidden: createFactory("Forbidden", HttpStatus.FORBIDDEN),
+    notFound: createFactory("Not Found", HttpStatus.NOT_FOUND),
+    methodNotAllowed: createFactory("Method Not Allowed", HttpStatus.METHOD_NOT_ALLOWED),
+    notAcceptable: createFactory("Not Acceptable", HttpStatus.NOT_ACCEPTABLE),
+    requestTimeout: createFactory("Request Timeout", HttpStatus.REQUEST_TIMEOUT),
+    conflict: createFactory("Conflict", HttpStatus.CONFLICT),
+    gone: createFactory("Gone", HttpStatus.GONE),
+    preconditionFailed: createFactory("Precondition Failed", HttpStatus.PRECONDITION_FAILED),
+    payloadTooLarge: createFactory("Payload Too Large", HttpStatus.PAYLOAD_TOO_LARGE),
+    unsupportedMediaType: createFactory("Unsupported Media Type", HttpStatus.UNSUPPORTED_MEDIA_TYPE),
+    imATeapot: createFactory("I'm a teapot", HttpStatus.I_AM_A_TEAPOT),
+    unprocessableEntity: createFactory("Unprocessable Entity", HttpStatus.UNPROCESSABLE_ENTITY),
+    internalServerError: createFactory("Internal Server Error", HttpStatus.INTERNAL_SERVER_ERROR),
+    notImplemented: createFactory("Not Implemented", HttpStatus.NOT_IMPLEMENTED),
+    badGateway: createFactory("Bad Gateway", HttpStatus.BAD_GATEWAY),
+    serviceUnavailable: createFactory("Service Unavailable", HttpStatus.SERVICE_UNAVAILABLE),
+    gatewayTimeout: createFactory("Gateway Timeout", HttpStatus.GATEWAY_TIMEOUT),
+    httpVersionNotSupported: createFactory("HTTP Version Not Supported", HttpStatus.HTTP_VERSION_NOT_SUPPORTED),
+};

package/dist/lib/http/http-verbs.d.ts

@@ -0,0 +1,12 @@
+export type HttpVerb = "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "CONNECT" | "OPTIONS" | "PATCH" | "*";
+export declare const HttpVerbs: {
+    readonly GET: "GET";
+    readonly HEAD: "HEAD";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+    readonly DELETE: "DELETE";
+    readonly CONNECT: "CONNECT";
+    readonly OPTIONS: "OPTIONS";
+    readonly PATCH: "PATCH";
+    readonly ALL: "*";
+};

package/dist/lib/http/http-verbs.js

@@ -0,0 +1,11 @@
+export const HttpVerbs = {
+    GET: "GET",
+    HEAD: "HEAD",
+    POST: "POST",
+    PUT: "PUT",
+    DELETE: "DELETE",
+    CONNECT: "CONNECT",
+    OPTIONS: "OPTIONS",
+    PATCH: "PATCH",
+    ALL: "*",
+};

package/dist/lib/http/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./decorators.js";
+export * from "./exceptions.js";
+export * from "./openapi-builder.js";

package/dist/lib/http/index.js

@@ -0,0 +1,3 @@
+export * from "./decorators.js";
+export * from "./exceptions.js";
+export * from "./openapi-builder.js";

package/dist/lib/http/openapi-builder.d.ts

@@ -0,0 +1,27 @@
+export interface RouteRegistration {
+    method: string;
+    path: string;
+    schema: RouteSchema;
+}
+export interface RouteSchema {
+    body?: unknown;
+    querystring?: unknown;
+    params?: unknown;
+    headers?: unknown;
+    response?: unknown;
+    description?: string;
+    summary?: string;
+    tags?: string[];
+    operationId?: string;
+    deprecated?: boolean;
+}
+export declare function hasValidationSchema(schema: RouteSchema): boolean;
+export declare class OpenAPIBuilder {
+    private routes;
+    registerRoute(method: string, path: string, schema: RouteSchema): void;
+    buildPaths(): Record<string, any>;
+    private buildOperation;
+    private buildParameters;
+    private buildRequestBody;
+    private buildResponses;
+}

package/dist/lib/http/openapi-builder.js

@@ -0,0 +1,83 @@
+export function hasValidationSchema(schema) {
+    return !!(schema?.body ||
+        schema?.querystring ||
+        schema?.params ||
+        schema?.headers);
+}
+export class OpenAPIBuilder {
+    routes = [];
+    registerRoute(method, path, schema) {
+        this.routes.push({ method: method.toLowerCase(), path, schema });
+    }
+    buildPaths() {
+        return this.routes.reduce((paths, route) => {
+            paths[route.path] ??= {};
+            paths[route.path][route.method] = this.buildOperation(route.schema);
+            return paths;
+        }, {});
+    }
+    buildOperation(schema) {
+        const parameters = this.buildParameters(schema);
+        const requestBody = this.buildRequestBody(schema);
+        const responses = this.buildResponses(schema);
+        return {
+            ...(schema.summary && { summary: schema.summary }),
+            ...(schema.description && { description: schema.description }),
+            ...(schema.tags && { tags: schema.tags }),
+            ...(schema.operationId && { operationId: schema.operationId }),
+            ...(schema.deprecated && { deprecated: schema.deprecated }),
+            ...(parameters.length > 0 && { parameters }),
+            ...(requestBody && { requestBody }),
+            responses,
+        };
+    }
+    buildParameters(schema) {
+        const parameters = [];
+        const querySchema = schema.querystring;
+        if (querySchema?.properties) {
+            parameters.push(...Object.entries(querySchema.properties).map(([name, propSchema]) => ({
+                name,
+                in: "query",
+                required: querySchema.required?.includes(name) ?? false,
+                schema: propSchema,
+            })));
+        }
+        const paramsSchema = schema.params;
+        if (paramsSchema?.properties) {
+            parameters.push(...Object.entries(paramsSchema.properties).map(([name, propSchema]) => ({
+                name,
+                in: "path",
+                required: true,
+                schema: propSchema,
+            })));
+        }
+        return parameters;
+    }
+    buildRequestBody(schema) {
+        return schema.body
+            ? {
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: schema.body,
+                    },
+                },
+            }
+            : undefined;
+    }
+    buildResponses(schema) {
+        if (!schema.response)
+            return {};
+        return Object.entries(schema.response).reduce((acc, [statusCode, responseSchema]) => {
+            acc[statusCode] = {
+                description: statusCode === "200" ? "Successful response" : "Response",
+                content: {
+                    "application/json": {
+                        schema: responseSchema,
+                    },
+                },
+            };
+            return acc;
+        }, {});
+    }
+}

package/dist/lib/mediator/contract.types.d.ts

@@ -0,0 +1,159 @@
+import type { EmptyObject } from "../di/common.types.js";
+import type { Module, ModuleDefinition, ModuleImport } from "../di/modules/module.types.js";
+import type { DefPreHandlerMap } from "../di/providers/provider.types.js";
+import type { GlobalCommandPreHandlers, GlobalQueryPreHandlers, NormalizeGlobalPreHandlerMap } from "./global-middlewares.types.js";
+import type { EmptyContext } from "./middleware.types.js";
+type QueryContractModuleDef = {
+    queryPreHandlers?: DefPreHandlerMap;
+    imports?: readonly ModuleImport[];
+};
+type EmptyModuleDef = Record<never, never>;
+type CommandContractModuleDef = {
+    commandPreHandlers?: DefPreHandlerMap;
+    imports?: readonly ModuleImport[];
+};
+type ContractScenario<TPreHandlerKey extends string> = {
+    name: string;
+    includePreHandlerKeys?: readonly TPreHandlerKey[];
+    excludePreHandlerKeys?: readonly TPreHandlerKey[];
+};
+type PreHandlerExportKey = "queryPreHandlerExports" | "commandPreHandlerExports";
+type ExtractModuleDef<T> = T extends Module<infer TDef extends ModuleDefinition> ? TDef : T extends Record<string, unknown> ? T : never;
+type ExtractExportedPreHandlerMap<TModuleDef, TExportKey extends PreHandlerExportKey> = TModuleDef extends {
+    [K in TExportKey]?: infer E;
+} ? [NonNullable<E>] extends [DefPreHandlerMap] ? NonNullable<E> : EmptyObject : EmptyObject;
+type ExtractPreHandlerMapFromImports<TImports extends readonly ModuleImport[] | undefined, TExportKey extends PreHandlerExportKey> = TImports extends readonly [
+    infer First,
+    ...infer Rest extends readonly ModuleImport[]
+] ? ExtractExportedPreHandlerMap<ExtractModuleDef<First>, TExportKey> & ExtractPreHandlerMapFromImports<Rest, TExportKey> : EmptyObject;
+type ExtractMiddlewareContract<M> = M extends {
+    readonly contract: infer C;
+} ? C : M extends new (...args: any[]) => infer I ? I extends {
+    readonly contract: infer C;
+} ? C : never : M extends {
+    useClass: infer U;
+} ? ExtractMiddlewareContract<U> : never;
+type ExtractContextData<T> = T extends Result<infer Data, any> ? Data extends Record<string, unknown> ? Data : never : T extends Record<string, unknown> ? T : never;
+type ExtractContextFromMiddleware<M> = ExtractMiddlewareContract<M> extends {
+    returnType: infer R;
+} ? ExtractContextData<R> : never;
+type ExtractErrorFromMiddleware<M> = ExtractMiddlewareContract<M> extends {
+    returnType: infer R;
+} ? ExtractResultError<R> : never;
+export type AnyContract = {
+    key: string;
+    payload: unknown;
+    response: unknown;
+    returnType?: unknown;
+    context?: Record<string, unknown>;
+    scenarios?: Record<string, unknown>;
+};
+export type QueryContract<K extends string, P, R, Scenarios extends ContractScenario<QueryPreHandlerKeys<M>> | never = never, M extends QueryContractModuleDef = EmptyModuleDef> = Contract<K, P, R> & WithScenario<QueryContractPreHandlerMap<M>, QueryPreHandlerKeys<M>, R, Scenarios> & {
+    returnType: QueryContractReturnType<M, R>;
+    context: ResolveQueryContractContext<M, Scenarios>;
+};
+export type CommandContract<K extends string, P, R, Scenarios extends ContractScenario<CommandPreHandlerKeys<M>> | never = never, M extends CommandContractModuleDef = EmptyModuleDef> = Contract<K, P, R> & {
+    returnType: CommandContractReturnType<M, R>;
+    context: ResolveCommandContractContext<M, Scenarios>;
+} & WithScenario<CommandContractPreHandlerMap<M>, CommandPreHandlerKeys<M>, R, Scenarios>;
+type QueryContractPreHandlerMap<M extends QueryContractModuleDef> = [
+    M
+] extends [never] ? NormalizeGlobalPreHandlerMap<GlobalQueryPreHandlers> : NonNullable<M["queryPreHandlers"]> & NormalizeGlobalPreHandlerMap<GlobalQueryPreHandlers> & ExtractPreHandlerMapFromImports<M["imports"], "queryPreHandlerExports">;
+type CommandContractPreHandlerMap<M extends CommandContractModuleDef> = [
+    M
+] extends [never] ? NormalizeGlobalPreHandlerMap<GlobalCommandPreHandlers> : NonNullable<M["commandPreHandlers"]> & NormalizeGlobalPreHandlerMap<GlobalCommandPreHandlers> & ExtractPreHandlerMapFromImports<M["imports"], "commandPreHandlerExports">;
+type QueryContractReturnType<M extends QueryContractModuleDef, R> = ResolveContractReturnTypeByModule<M, NormalizeGlobalPreHandlerMap<GlobalQueryPreHandlers>, QueryContractPreHandlerMap<M>, R>;
+type CommandContractReturnType<M extends CommandContractModuleDef, R> = ResolveContractReturnTypeByModule<M, NormalizeGlobalPreHandlerMap<GlobalCommandPreHandlers>, CommandContractPreHandlerMap<M>, R>;
+type QueryPreHandlerKeys<M extends QueryContractModuleDef> = [M] extends [never] ? Extract<keyof NormalizeGlobalPreHandlerMap<GlobalQueryPreHandlers>, string> : Extract<keyof NonNullable<M["queryPreHandlers"]>, string> | Extract<keyof NormalizeGlobalPreHandlerMap<GlobalQueryPreHandlers>, string> | Extract<keyof ExtractPreHandlerMapFromImports<M["imports"], "queryPreHandlerExports">, string>;
+type CommandPreHandlerKeys<M extends CommandContractModuleDef> = [M] extends [
+    never
+] ? Extract<keyof NormalizeGlobalPreHandlerMap<GlobalCommandPreHandlers>, string> : Extract<keyof NonNullable<M["commandPreHandlers"]>, string> | Extract<keyof NormalizeGlobalPreHandlerMap<GlobalCommandPreHandlers>, string> | Extract<keyof ExtractPreHandlerMapFromImports<M["imports"], "commandPreHandlerExports">, string>;
+type WithScenario<TPreHandlerMap, TPreHandlerKey extends string, R, Scenarios extends ContractScenario<TPreHandlerKey> | never> = [Scenarios] extends [never] ? Record<never, never> : {
+    scenarios: ResolveScenarioResponseMap<TPreHandlerMap, TPreHandlerKey, R, Scenarios>;
+};
+type ExtractIncludedPreHandlerMap<TMap, TAllKeys extends string, TScenario> = NormalizeScenarioWithDefaultInclude<TScenario, TAllKeys> extends {
+    includePreHandlerKeys: infer Include extends readonly any[];
+} ? Pick<TMap, Extract<Include[number], TAllKeys>> : TMap;
+type NormalizeScenarioWithDefaultInclude<TScenario, TAllKeys extends string> = TScenario extends {
+    includePreHandlerKeys: readonly any[];
+} ? TScenario : TScenario & {
+    includePreHandlerKeys: readonly TAllKeys[];
+};
+type ExtractScenarioPreHandlerMap<TMap, TAllKeys extends string, TScenario> = ExtractIncludedPreHandlerMap<TMap, TAllKeys, TScenario> extends infer TIncluded ? TScenario extends {
+    excludePreHandlerKeys: infer Exclude extends readonly any[];
+} ? Omit<TIncluded, Extract<Exclude[number], keyof TIncluded>> : TIncluded : EmptyContext;
+type ResolveScenarioContext<TPreHandlerMap, TPreHandlerKey extends string, Scenarios extends ContractScenario<TPreHandlerKey>> = Scenarios extends ContractScenario<TPreHandlerKey> ? ResolveContextOrEmpty<ContextFromPreHandlerMap<ExtractScenarioPreHandlerMap<TPreHandlerMap, TPreHandlerKey, Scenarios>>> : never;
+type ExtractPreHandlerErrorsFromMap<TMap> = [
+    Extract<keyof TMap, string>
+] extends [never] ? never : {
+    [K in Extract<keyof TMap, string>]: ExtractErrorFromMiddleware<TMap[K]>;
+}[Extract<keyof TMap, string>];
+type ResolveScenarioResponse<TPreHandlerMap, TPreHandlerKey extends string, R, Scenario extends ContractScenario<TPreHandlerKey>> = ResponseWithErrors<R, ExtractPreHandlerErrorsFromMap<ExtractScenarioPreHandlerMap<TPreHandlerMap, TPreHandlerKey, Scenario>>>;
+type ResolveContractReturnType<TPreHandlerErrors, R> = MergeResponseWithPreHandlerErrors<R, TPreHandlerErrors>;
+type ResolveContractReturnTypeByModule<M, TGlobalPreHandlerMap, TContractPreHandlerMap, R> = [keyof M] extends [never] ? ResolveContractReturnType<ExtractPreHandlerErrorsFromMap<TGlobalPreHandlerMap>, R> : ResolveContractReturnType<ExtractPreHandlerErrorsFromMap<TContractPreHandlerMap>, R>;
+type ResolveScenarioResponseMap<TPreHandlerMap, TPreHandlerKey extends string, R, Scenarios extends ContractScenario<TPreHandlerKey>> = {
+    [Scenario in Scenarios as Scenario["name"]]: {
+        config: Omit<Scenario, "name">;
+        returnType: ResolveScenarioResponse<TPreHandlerMap, TPreHandlerKey, R, Scenario>;
+    };
+};
+type ContextFromMiddlewareOrEmpty<TMiddleware> = [
+    ExtractContextFromMiddleware<TMiddleware>
+] extends [never] ? EmptyContext : ExtractContextFromMiddleware<TMiddleware>;
+type ResolveContextOrEmpty<TContext> = [TContext] extends [
+    Record<string, unknown>
+] ? TContext : EmptyContext;
+type ContextFromPreHandlerMap<TMap> = Extract<keyof TMap, string> extends never ? EmptyContext : UnionToIntersection<{
+    [K in Extract<keyof TMap, string>]: ContextFromMiddlewareOrEmpty<TMap[K]>;
+}[Extract<keyof TMap, string>]>;
+type Contract<K extends string, P, R> = {
+    key: K;
+    payload: P;
+    response: R;
+};
+type ResolveQueryContractContext<M extends QueryContractModuleDef, Scenarios extends ContractScenario<QueryPreHandlerKeys<M>>> = [Scenarios] extends [never] ? ResolveContextOrEmpty<ContextFromPreHandlerMap<QueryContractPreHandlerMap<M>>> : ResolveScenarioContext<QueryContractPreHandlerMap<M>, QueryPreHandlerKeys<M>, Scenarios>;
+type ResolveCommandContractContext<M extends CommandContractModuleDef, Scenarios extends ContractScenario<CommandPreHandlerKeys<M>>> = [Scenarios] extends [never] ? ResolveContextOrEmpty<ContextFromPreHandlerMap<CommandContractPreHandlerMap<M>>> : ResolveScenarioContext<CommandContractPreHandlerMap<M>, CommandPreHandlerKeys<M>, Scenarios>;
+type ExtractResultSuccess<R> = R extends {
+    readonly ok: true;
+    readonly value: infer T;
+} ? T : never;
+type ExtractResultError<R> = R extends {
+    readonly ok: false;
+    readonly error: infer E;
+} ? E : never;
+type IsResult<R> = R extends {
+    readonly ok: true;
+    readonly value: any;
+} | {
+    readonly ok: false;
+    readonly error: any;
+} ? true : false;
+type ResponseWithErrors<Response, Errors> = [Errors] extends [never] ? Response : IsResult<Response> extends true ? Result<ExtractResultSuccess<Response>, ExtractResultError<Response> | Errors> : Result<Response, Errors>;
+type Result<Value, Err> = {
+    readonly ok: true;
+    readonly value: Value;
+    readonly error: undefined;
+} | {
+    readonly ok: false;
+    readonly value: undefined;
+    readonly error: Err;
+};
+type MergeResponseWithPreHandlerErrors<TResponse, TPreHandlerError> = [
+    TPreHandlerError
+] extends [never] ? TResponse : [TResponse] extends [{
+    readonly ok: true;
+    readonly value: infer V;
+}] ? Result<V, TPreHandlerError> : [TResponse] extends [{
+    readonly ok: false;
+    readonly error: infer E;
+}] ? Result<never, E | TPreHandlerError> : [TResponse] extends [
+    {
+        readonly ok: true;
+        readonly value: infer V;
+    } | {
+        readonly ok: false;
+        readonly error: infer E;
+    }
+] ? Result<V, E | TPreHandlerError> : Result<TResponse, TPreHandlerError>;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export {};

package/dist/lib/mediator/contract.types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/mediator/errors.d.ts

@@ -0,0 +1,15 @@
+export declare class HandlerAlreadyRegisteredError extends Error {
+    constructor(handlerKey: string);
+}
+export declare class HandlerNotRegisteredError extends Error {
+    constructor(handlerKey: string, moduleName: string);
+}
+export declare class InvalidMiddlewareReturnValueError extends Error {
+    constructor(middlewareKey: string, returnedType: string);
+}
+export declare class ContextKeyConflictError extends Error {
+    constructor(middlewareKey: string, conflictingKeys: string[]);
+}
+export declare class MiddlewareRequiredError extends Error {
+    constructor(middlewareKey: string, requiredKey: string);
+}

package/dist/lib/mediator/errors.js

@@ -0,0 +1,33 @@
+export class HandlerAlreadyRegisteredError extends Error {
+    constructor(handlerKey) {
+        super(`Handler "${handlerKey}" already registered!`);
+        this.name = "HandlerAlreadyRegisteredError";
+    }
+}
+export class HandlerNotRegisteredError extends Error {
+    constructor(handlerKey, moduleName) {
+        super(`Handler key of ${handlerKey} is not registered in module: "${moduleName}"`);
+        this.name = "HandlerNotRegisteredError";
+    }
+}
+export class InvalidMiddlewareReturnValueError extends Error {
+    constructor(middlewareKey, returnedType) {
+        super(`Middleware "${middlewareKey}" returned invalid value of type "${returnedType}". ` +
+            `Middlewares must return a Result type or a plain object for context merging.`);
+        this.name = "InvalidMiddlewareReturnValueError";
+    }
+}
+export class ContextKeyConflictError extends Error {
+    constructor(middlewareKey, conflictingKeys) {
+        super(`Middleware "${middlewareKey}" tried to add context keys that already exist: ${conflictingKeys.join(", ")}. ` +
+            `Each middleware must add unique keys to the context.`);
+        this.name = "ContextKeyConflictError";
+    }
+}
+export class MiddlewareRequiredError extends Error {
+    constructor(middlewareKey, requiredKey) {
+        super(`Middleware "${middlewareKey}" requires "${requiredKey}" to run before it. ` +
+            `Ensure "${requiredKey}" is included and appears before "${middlewareKey}" in the execution order.`);
+        this.name = "MiddlewareRequiredError";
+    }
+}

package/dist/lib/mediator/global-middlewares.types.d.ts

@@ -0,0 +1,13 @@
+import type { EmptyObject } from "../di/common.types.js";
+import type { DefPreHandlerMap } from "../di/providers/provider.types.js";
+export interface GlobalQueryPreHandlers {
+}
+export interface GlobalCommandPreHandlers {
+}
+export type NormalizeGlobalPreHandlerMap<T> = [T] extends [DefPreHandlerMap] ? T : EmptyObject;
+export type InferGlobalQueryPreHandlers<TModuleDef> = TModuleDef extends {
+    queryPreHandlerExports: infer TPreHandlers;
+} ? NormalizeGlobalPreHandlerMap<TPreHandlers> : EmptyObject;
+export type InferGlobalCommandPreHandlers<TModuleDef> = TModuleDef extends {
+    commandPreHandlerExports: infer TPreHandlers;
+} ? NormalizeGlobalPreHandlerMap<TPreHandlers> : EmptyObject;

package/dist/lib/mediator/global-middlewares.types.js

@@ -0,0 +1 @@
+export {};