awilixify 2.2.1 → 3.1.0

package/dist/lib/di/providers/provider-dependency-sorter.d.ts

@@ -0,0 +1,9 @@
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+export declare class ProviderDependencySorter {
+    sortByDependencies(m: M): NonNullable<typeof m.providers>;
+    private initializeDepGraph;
+    private buildDepGraph;
+    private sortTopologically;
+    private initializeQueue;
+    private ensureNoCyclicDependencies;
+}

package/dist/lib/di/providers/provider-dependency-sorter.js

@@ -0,0 +1,76 @@
+import * as ERRORS from "../errors.js";
+import { isFactoryProvider, isForwardRef, isPromiseLike, } from "../type-guards.js";
+export class ProviderDependencySorter {
+    sortByDependencies(m) {
+        const depsGraph = this.buildDepGraph(m, this.initializeDepGraph(m));
+        const initialQueue = this.initializeQueue(depsGraph.inDegree);
+        const sortedKeys = this.sortTopologically(depsGraph, initialQueue);
+        this.ensureNoCyclicDependencies(m, sortedKeys);
+        return sortedKeys.reduce((acc, key) => {
+            const provider = m.providers?.[key];
+            if (provider !== undefined)
+                acc[key] = provider;
+            return acc;
+        }, {});
+    }
+    initializeDepGraph(m) {
+        return Object.keys(m.providers || {}).reduce((acc, curr) => {
+            acc.graph.set(curr, []);
+            acc.inDegree.set(curr, 0);
+            return acc;
+        }, {
+            graph: new Map(),
+            inDegree: new Map(),
+        });
+    }
+    buildDepGraph(m, depsGraph) {
+        const importedProviderKeys = new Set((m.imports || []).flatMap((importItem) => {
+            const importedModule = isForwardRef(importItem)
+                ? importItem.resolve()
+                : importItem;
+            if (isPromiseLike(importedModule)) {
+                throw new Error(`Async module import in "${m.name}" was not resolved before provider dependency sorting.`);
+            }
+            return importedModule.exports ? [...importedModule.exports] : [];
+        }));
+        return Object.entries(m.providers || {}).reduce((acc, [key, provider]) => {
+            if (!isFactoryProvider(provider) || !provider.inject)
+                return acc;
+            provider.inject.forEach((dep) => {
+                const depList = acc.graph.get(dep);
+                if (depList) {
+                    depList.push(key);
+                    acc.inDegree.set(key, (acc.inDegree.get(key) || 0) + 1);
+                    return;
+                }
+                if (!depList && !importedProviderKeys.has(dep)) {
+                    throw new ERRORS.DependencyNotFoundError(dep, m.name);
+                }
+            });
+            return acc;
+        }, { ...depsGraph });
+    }
+    sortTopologically(depsGraph, queue, result = []) {
+        const [current, ...restQueue] = queue;
+        if (!current)
+            return result;
+        const deps = depsGraph.graph.get(current) || [];
+        const inDegree = deps.reduce((acc, curr) => {
+            acc.set(curr, (acc.get(curr) || 0) - 1);
+            return acc;
+        }, new Map(depsGraph.inDegree));
+        return this.sortTopologically({ ...depsGraph, inDegree }, [...restQueue, ...deps.filter((dep) => inDegree.get(dep) === 0)], [...result, current]);
+    }
+    initializeQueue(inDegree) {
+        return Array.from(inDegree.entries())
+            .filter(([_, degree]) => degree === 0)
+            .map(([key]) => key);
+    }
+    ensureNoCyclicDependencies(m, sortedKeys) {
+        const providerKeys = Object.keys(m.providers || {});
+        if (sortedKeys.length !== providerKeys.length) {
+            const remaining = providerKeys.filter((key) => !sortedKeys.includes(key));
+            throw new ERRORS.CircularDependencyError(m.name, remaining);
+        }
+    }
+}

package/dist/lib/di/providers/provider-resolver.d.ts

@@ -0,0 +1,35 @@
+import * as Awilix from "awilix";
+import type { DevtoolsProcessorRef } from "../../devtools/devtools.types.js";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import type { InterceptorProcessor } from "../processors/interceptor-processor.js";
+import type { AnyProvider } from "./provider.types.js";
+export type RequestScopeResolver = (scope: Awilix.AwilixContainer) => Awilix.AwilixContainer;
+type ResolveProviderParams = {
+    key: string;
+    moduleId?: string;
+    provider: AnyProvider;
+    resolutionScope: Awilix.AwilixContainer;
+    module: M;
+};
+type ResolveClassProviderParams = {
+    provider: unknown;
+    resolutionScope: Awilix.AwilixContainer;
+    module: M;
+    providerOptions?: Partial<Awilix.BuildResolverOptions<any>>;
+    wrapForExport?: boolean;
+};
+export declare class ProviderResolver {
+    private readonly interceptorProcessor;
+    private readonly providerOptions;
+    private readonly devtoolsProcessorRef;
+    private readonly requestScopeResolver?;
+    constructor(interceptorProcessor: InterceptorProcessor | undefined, providerOptions: Partial<Awilix.BuildResolverOptions<any>>, devtoolsProcessorRef: DevtoolsProcessorRef, requestScopeResolver?: RequestScopeResolver | undefined);
+    static mergeResolverOptions(module: M, providerOptions: Partial<Awilix.BuildResolverOptions<any>>, options?: Partial<Awilix.BuildResolverOptions<any>>): Awilix.BuildResolverOptions<any>;
+    resolveClassProvider({ provider, resolutionScope, module, wrapForExport, }: ResolveClassProviderParams): Awilix.Resolver<any>;
+    resolveProvider({ key, moduleId, provider, resolutionScope, module, }: ResolveProviderParams): Awilix.Resolver<any>;
+    resolveProviderAsync({ key, moduleId, provider, resolutionScope, module, }: ResolveProviderParams): Promise<Awilix.Resolver<any>>;
+    private extractResolverOptions;
+    private createProxyResolver;
+    private get devtoolsTracer();
+}
+export {};

package/dist/lib/di/providers/provider-resolver.js

@@ -0,0 +1,168 @@
+import * as Awilix from "awilix";
+import * as ERRORS from "../errors.js";
+import * as GUARGS from "../type-guards.js";
+export class ProviderResolver {
+    interceptorProcessor;
+    providerOptions;
+    devtoolsProcessorRef;
+    requestScopeResolver;
+    constructor(interceptorProcessor, providerOptions, devtoolsProcessorRef, requestScopeResolver) {
+        this.interceptorProcessor = interceptorProcessor;
+        this.providerOptions = providerOptions;
+        this.devtoolsProcessorRef = devtoolsProcessorRef;
+        this.requestScopeResolver = requestScopeResolver;
+    }
+    static mergeResolverOptions(module, providerOptions, options) {
+        return {
+            ...providerOptions,
+            ...module.providerOptions,
+            ...options,
+        };
+    }
+    resolveClassProvider({ provider, resolutionScope, module, wrapForExport, }) {
+        const { useClass, ...featureOptions } = GUARGS.hasUseClass(provider)
+            ? provider
+            : { useClass: provider };
+        const resolverOptions = {
+            ...this.providerOptions,
+            ...module.providerOptions,
+            ...featureOptions,
+        };
+        const resolver = Awilix.asClass(useClass, resolverOptions);
+        if (!wrapForExport)
+            return resolver;
+        return Awilix.asFunction(() => resolver.resolve(resolverOptions.lifetime === Awilix.Lifetime.SINGLETON
+            ? resolutionScope
+            : this.requestScopeResolver
+                ? this.requestScopeResolver(resolutionScope)
+                : resolutionScope), resolverOptions);
+    }
+    resolveProvider({ key, moduleId, provider, resolutionScope, module, }) {
+        if (GUARGS.isPrimitive(provider)) {
+            return Awilix.asValue(provider);
+        }
+        if (GUARGS.isPlainFunction(provider) &&
+            !GUARGS.isCostructorProvider(provider)) {
+            return Awilix.asValue(provider);
+        }
+        if (typeof provider === "object" &&
+            !GUARGS.isCostructorProvider(provider) &&
+            !GUARGS.isFactoryProvider(provider) &&
+            !GUARGS.hasUseClass(provider)) {
+            return Awilix.asValue(provider);
+        }
+        const resolverOptions = this.extractResolverOptions(module, provider);
+        if (GUARGS.isCostructorProvider(provider)) {
+            const resolver = !this.interceptorProcessor
+                ? Awilix.asClass(provider, resolverOptions)
+                : this.interceptorProcessor.createInterceptedProviderResolver({
+                    module,
+                    useClass: provider,
+                    options: resolverOptions,
+                });
+            if (!this.devtoolsTracer)
+                return resolver;
+            return this.devtoolsTracer.wrapResolver({
+                kind: "provider",
+                module,
+                moduleId,
+                options: resolverOptions,
+                providerKey: key,
+                resolver,
+            });
+        }
+        if (GUARGS.isFactoryProvider(provider)) {
+            if (GUARGS.isAsyncFactoryProvider(provider)) {
+                if (GUARGS.isEagerProvider(provider)) {
+                    return Awilix.asFunction(() => {
+                        throw new ERRORS.AsyncEagerFactoryRequiresInitError(module.name, key ?? "unknown");
+                    }, resolverOptions);
+                }
+                throw new ERRORS.AsyncFactoryRequiresAsyncCreateError(module.name, key ?? "unknown");
+            }
+            const factoryDeps = (provider.inject || []).map((k) => resolutionScope.registrations[k].resolve(resolutionScope));
+            const resolver = Awilix.asFunction(() => provider.useFactory(...factoryDeps), resolverOptions);
+            if (!this.devtoolsTracer)
+                return resolver;
+            return this.devtoolsTracer.wrapResolver({
+                kind: "provider",
+                module,
+                moduleId,
+                options: resolverOptions,
+                providerKey: key,
+                isFactory: true,
+                resolver,
+            });
+        }
+        const baseResolver = Awilix.asClass(provider.useClass, resolverOptions);
+        const classResolver = provider.allowCircular
+            ? this.createProxyResolver(baseResolver, resolverOptions)
+            : baseResolver;
+        const resolver = !this.interceptorProcessor
+            ? classResolver
+            : this.interceptorProcessor.createInterceptedProviderResolver({
+                module,
+                useClass: provider.useClass,
+                options: resolverOptions,
+                resolver: classResolver,
+            });
+        if (!this.devtoolsTracer)
+            return resolver;
+        return this.devtoolsTracer.wrapResolver({
+            kind: "provider",
+            module,
+            moduleId,
+            options: resolverOptions,
+            providerKey: key,
+            resolver,
+        });
+    }
+    async resolveProviderAsync({ key, moduleId, provider, resolutionScope, module, }) {
+        if (!GUARGS.isFactoryProvider(provider) ||
+            !GUARGS.isAsyncFactoryProvider(provider)) {
+            return this.resolveProvider({
+                provider,
+                resolutionScope,
+                module,
+                key,
+                moduleId,
+            });
+        }
+        const resolverOptions = this.extractResolverOptions(module, provider);
+        if (resolverOptions.lifetime !== Awilix.Lifetime.SINGLETON) {
+            throw new ERRORS.AsyncFactoryRequiresSingletonLifetimeError(module.name, key);
+        }
+        const factoryDeps = (provider.inject || []).map((k) => resolutionScope.registrations[k].resolve(resolutionScope));
+        return Awilix.asValue(await provider.useFactory(...factoryDeps));
+    }
+    extractResolverOptions(module, provider) {
+        if (GUARGS.hasUseClass(provider)) {
+            const { useClass, allowCircular, eager, initAfter, ...options } = provider;
+            return ProviderResolver.mergeResolverOptions(module, this.providerOptions, options);
+        }
+        if (GUARGS.isFactoryProvider(provider)) {
+            const { eager, initAfter, inject, useFactory, ...options } = provider;
+            return ProviderResolver.mergeResolverOptions(module, this.providerOptions, options);
+        }
+        return ProviderResolver.mergeResolverOptions(module, this.providerOptions);
+    }
+    createProxyResolver(resolver, options) {
+        return Awilix.createBuildResolver({
+            ...options,
+            resolve(container) {
+                let resolved = null;
+                return new Proxy({}, {
+                    get(_, name) {
+                        if (!resolved) {
+                            resolved = resolver.resolve(container);
+                        }
+                        return resolved[name];
+                    },
+                });
+            },
+        });
+    }
+    get devtoolsTracer() {
+        return this.devtoolsProcessorRef.current?.tracer;
+    }
+}

package/dist/lib/di/providers/provider.types.d.ts

@@ -0,0 +1 @@
+export * from "./types/index.js";

package/dist/lib/di/providers/provider.types.js

@@ -0,0 +1 @@
+export * from "./types/index.js";

package/dist/lib/di/providers/types/controller.types.d.ts

@@ -0,0 +1,9 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+export type ConstructorController = Constructor<Controller>;
+export type ClassController = {
+    useClass: ConstructorController | Constructor<any>;
+} & BuildResolverOptions<any>;
+export type AnyController = ConstructorController | ClassController | Constructor<any>;
+export interface Controller {
+    registerRoutes: () => void;
+}

package/dist/lib/di/providers/types/controller.types.js

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

package/dist/lib/di/providers/types/decorator-context.types.d.ts

@@ -0,0 +1,9 @@
+import type { DecoratorMethodState, DecoratorState, DecoratorToken, MethodName } from "../../../decorators/decorator-state.types.js";
+export type AnyDecoratorToken = DecoratorToken<DecoratorState<any, any>>;
+export type DecoratorExecutionContext<TToken extends AnyDecoratorToken = AnyDecoratorToken, TTarget extends object = object> = {
+    target: TTarget;
+    methodName: MethodName;
+    moduleName: string;
+    metadata: DecoratorMethodState<TToken["state"]>;
+    decoratorState: TToken["state"];
+};

package/dist/lib/di/providers/types/decorator-context.types.js

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

package/dist/lib/di/providers/types/handler.types.d.ts

@@ -0,0 +1,9 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+import type { AnyContract } from "lib/mediator/contract.types.js";
+import type { Handler } from "lib/mediator/handler.types.js";
+export interface ConstructorHandler<C extends AnyContract = AnyContract> {
+    new (...args: any[]): Handler<C>;
+}
+export type ClassHandler<H extends Constructor<any> = Constructor<any>> = {
+    useClass: H;
+} & BuildResolverOptions<any>;

package/dist/lib/di/providers/types/handler.types.js

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

package/dist/lib/di/providers/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./controller.types.js";
+export * from "./decorator-context.types.js";
+export * from "./handler.types.js";
+export * from "./initializer.types.js";
+export * from "./interceptor.types.js";
+export * from "./middleware.types.js";
+export * from "./provider.types.js";

package/dist/lib/di/providers/types/index.js

@@ -0,0 +1,7 @@
+export * from "./controller.types.js";
+export * from "./decorator-context.types.js";
+export * from "./handler.types.js";
+export * from "./initializer.types.js";
+export * from "./interceptor.types.js";
+export * from "./middleware.types.js";
+export * from "./provider.types.js";

package/dist/lib/di/providers/types/initializer.types.d.ts

@@ -0,0 +1,16 @@
+import type { Constructor } from "awilix";
+import type { AnyDecoratorToken, DecoratorExecutionContext } from "./decorator-context.types.js";
+export type DefInitializerMap = Record<string, ConstructorInitializer>;
+export interface ConstructorInitializer {
+    new (...args: any[]): Initializer<any, boolean>;
+}
+export type MetadataInitializerContext<TToken extends AnyDecoratorToken = AnyDecoratorToken> = DecoratorExecutionContext<TToken, Constructor<any>>;
+export type InitializerContext<TToken extends AnyDecoratorToken = AnyDecoratorToken> = MetadataInitializerContext<TToken> & {
+    invoke: (...args: unknown[]) => unknown | Promise<unknown>;
+};
+export declare abstract class Initializer<TToken extends AnyDecoratorToken = AnyDecoratorToken, TUsesInvoke extends boolean = true> {
+    abstract readonly token: TToken;
+    readonly usesInvoke: TUsesInvoke;
+    abstract initialize(context: TUsesInvoke extends true ? InitializerContext<TToken> : MetadataInitializerContext<TToken>): void | Promise<void>;
+}
+export type AnyInitializer = ConstructorInitializer;

package/dist/lib/di/providers/types/initializer.types.js

@@ -0,0 +1,3 @@
+export class Initializer {
+    usesInvoke = true;
+}

package/dist/lib/di/providers/types/interceptor.types.d.ts

@@ -0,0 +1,18 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+import type { AnyDecoratorToken, DecoratorExecutionContext } from "./decorator-context.types.js";
+export type DefInterceptorMap = Record<string, object>;
+export interface ConstructorInterceptor {
+    new (...args: any[]): Interceptor;
+}
+export type ClassInterceptor<I extends Constructor<any> = Constructor<any>> = {
+    useClass: I;
+} & BuildResolverOptions<any>;
+export type AnyInterceptor = ClassInterceptor | ConstructorInterceptor;
+export type InterceptContext<TToken extends AnyDecoratorToken = AnyDecoratorToken> = DecoratorExecutionContext<TToken> & {
+    args: unknown[];
+    proceed: () => unknown | Promise<unknown>;
+};
+export interface Interceptor<TToken extends AnyDecoratorToken = AnyDecoratorToken> {
+    token: TToken;
+    intercept(context: InterceptContext<TToken>): unknown | Promise<unknown>;
+}

package/dist/lib/di/providers/types/interceptor.types.js

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

package/dist/lib/di/providers/types/middleware.types.d.ts

@@ -0,0 +1,10 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+import type { AnyMiddlewareContract, Middleware } from "lib/mediator/middleware.types.js";
+export type DefPreHandlerMap = Record<string, object>;
+export interface ConstructorMiddleware<C extends AnyMiddlewareContract = AnyMiddlewareContract> {
+    new (...args: any[]): Middleware<C>;
+}
+export type ClassMiddleware<M extends Constructor<any> = Constructor<any>> = {
+    useClass: M;
+} & BuildResolverOptions<any>;
+export type AnyMiddleware = ClassMiddleware | Constructor<Middleware>;

package/dist/lib/di/providers/types/middleware.types.js

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

package/dist/lib/di/providers/types/provider.types.d.ts

@@ -0,0 +1,26 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+export type DefProviderMap = Record<string, object | string | boolean | number>;
+export type ConstructorProvider<T extends object = object> = Constructor<T>;
+export type PrimitiveProvider = string | number | boolean | symbol | bigint;
+export type FunctionProvider = (...args: any[]) => any;
+export type FactoryProvider<T extends object, DepsMap extends Record<string, unknown>, Keys extends readonly Extract<keyof DepsMap, string>[], Strict extends boolean = true, ResolverOptions extends object = BuildResolverOptions<T>> = {
+    inject?: Keys;
+    initAfter?: readonly Extract<keyof DepsMap, string>[];
+    eager?: boolean;
+    useFactory: Strict extends true ? (...args: MapKeysToValues<DepsMap, Keys>) => T | Promise<T> : (...args: any[]) => T | Promise<T>;
+} & ResolverOptions;
+export type ClassProvider<T extends object, DepsMap extends Record<string, unknown> = Record<string, unknown>, ResolverOptions extends object = BuildResolverOptions<T>> = {
+    useClass: Constructor<T>;
+    allowCircular?: boolean;
+    eager?: boolean;
+    initAfter?: readonly Extract<keyof DepsMap, string>[];
+} & ResolverOptions;
+export interface ProviderInit {
+    init(): void | Promise<void>;
+}
+export type Provider<T extends object, DepsMap extends Record<string, unknown> = Record<string, unknown>, ResolverOptions extends object = BuildResolverOptions<T>> = FactoryProvider<T, DepsMap, readonly Extract<keyof DepsMap, string>[], false> | ClassProvider<T, DepsMap, ResolverOptions> | ConstructorProvider<T>;
+export type AnyProvider = FactoryProvider<any, any, readonly string[], false> | ClassProvider<any> | ConstructorProvider<any> | PrimitiveProvider | FunctionProvider | object;
+type MapKeysToValues<DepsMap extends Record<string, unknown>, Keys extends readonly Extract<keyof DepsMap, string>[]> = {
+    [K in keyof Keys]: Keys[K] extends keyof DepsMap ? DepsMap[Keys[K]] : never;
+};
+export {};

package/dist/lib/di/providers/types/provider.types.js

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

package/dist/lib/di/request-scope-context.d.ts

@@ -0,0 +1,5 @@
+import type * as Awilix from "awilix";
+export declare function runInRequestScopeContext<T>(fn: () => T): T;
+export declare function hasRequestScopeContext(): boolean;
+export declare function getOrCreateRequestScope(scope: Awilix.AwilixContainer): Awilix.AwilixContainer;
+export declare function resolveFromRequestScope<T>(scope: Awilix.AwilixContainer, token: string | symbol): T;

package/dist/lib/di/request-scope-context.js

@@ -0,0 +1,28 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const requestScopeStorage = new AsyncLocalStorage();
+export function runInRequestScopeContext(fn) {
+    const existingStore = requestScopeStorage.getStore();
+    if (existingStore) {
+        return fn();
+    }
+    return requestScopeStorage.run(new Map(), fn);
+}
+export function hasRequestScopeContext() {
+    return !!requestScopeStorage.getStore();
+}
+export function getOrCreateRequestScope(scope) {
+    const store = requestScopeStorage.getStore();
+    if (!store) {
+        return scope.createScope();
+    }
+    const existingScope = store.get(scope);
+    if (existingScope) {
+        return existingScope;
+    }
+    const requestScope = scope.createScope();
+    store.set(scope, requestScope);
+    return requestScope;
+}
+export function resolveFromRequestScope(scope, token) {
+    return getOrCreateRequestScope(scope).resolve(token);
+}

package/dist/lib/di/type-guards.d.ts

@@ -0,0 +1,35 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+import type { ForwardRef } from "./modules/module-ref.types.js";
+import type { FactoryProvider, FunctionProvider, PrimitiveProvider } from "./providers/provider.types.js";
+export declare function hasUseClass<T extends object = object>(value: unknown): value is {
+    useClass: Constructor<T>;
+    allowCircular?: boolean;
+    eager?: boolean;
+    initAfter?: readonly string[];
+} & Partial<BuildResolverOptions<any>>;
+export declare function isFactoryProvider<T extends object>(provider: unknown): provider is FactoryProvider<T, any, readonly string[], false>;
+export declare function isAsyncFactoryProvider(provider: unknown): boolean;
+export declare function isCostructorProvider<T extends object>(provider: unknown): provider is Constructor<T>;
+export declare function isPrimitive(provider: unknown): provider is PrimitiveProvider;
+export declare function isPlainFunction(provider: unknown): provider is FunctionProvider;
+export declare function isForwardRef(value: unknown): value is ForwardRef;
+export declare function isPromiseLike<T = unknown>(value: unknown): value is Promise<T>;
+export declare function isEagerProvider(provider: unknown): provider is {
+    eager: true;
+};
+export declare function hasProviderInit(value: unknown): value is {
+    init: () => void | Promise<void>;
+};
+export declare function hasProviderPostInit(value: unknown): value is {
+    postInit: () => void | Promise<void>;
+};
+export declare function hasInitAfter(provider: unknown): provider is {
+    initAfter: readonly string[];
+};
+export declare function isResultLike(value: unknown): value is {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: unknown;
+};

package/dist/lib/di/type-guards.js

@@ -0,0 +1,84 @@
+export function hasUseClass(value) {
+    return typeof value === "object" && value !== null && "useClass" in value;
+}
+export function isFactoryProvider(provider) {
+    return (typeof provider === "object" &&
+        provider !== null &&
+        "useFactory" in provider);
+}
+export function isAsyncFactoryProvider(provider) {
+    return (isFactoryProvider(provider) &&
+        provider.useFactory.constructor.name === "AsyncFunction");
+}
+export function isCostructorProvider(provider) {
+    if (typeof provider !== "function")
+        return false;
+    if (!("prototype" in provider))
+        return false;
+    const proto = provider.prototype;
+    if (!proto || typeof proto !== "object")
+        return false;
+    const protoKeys = Object.getOwnPropertyNames(proto);
+    if (protoKeys.length === 0 ||
+        (protoKeys.length === 1 && protoKeys[0] === "constructor")) {
+        return provider.toString().trim().startsWith("class");
+    }
+    return true;
+}
+export function isPrimitive(provider) {
+    return (typeof provider === "string" ||
+        typeof provider === "number" ||
+        typeof provider === "boolean" ||
+        typeof provider === "symbol" ||
+        typeof provider === "bigint");
+}
+export function isPlainFunction(provider) {
+    return (typeof provider === "function" &&
+        (!provider.prototype || Object.keys(provider.prototype).length === 0));
+}
+export function isForwardRef(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "__forward_ref__" in value &&
+        value.__forward_ref__ === true &&
+        "resolve" in value &&
+        typeof value.resolve === "function");
+}
+export function isPromiseLike(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "then" in value &&
+        typeof value.then === "function");
+}
+export function isEagerProvider(provider) {
+    return (typeof provider === "object" &&
+        provider !== null &&
+        "eager" in provider &&
+        provider.eager === true);
+}
+export function hasProviderInit(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "init" in value &&
+        typeof value.init === "function");
+}
+export function hasProviderPostInit(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "postInit" in value &&
+        typeof value.postInit === "function");
+}
+export function hasInitAfter(provider) {
+    return (typeof provider === "object" &&
+        provider !== null &&
+        "initAfter" in provider &&
+        Array.isArray(provider.initAfter));
+}
+export function isResultLike(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "ok" in value &&
+        (value.ok === true
+            ? "value" in value
+            : value.ok === false && "error" in value));
+}

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

@@ -0,0 +1,33 @@
+import type { DecoratorState, DecoratorToken } from "../decorators/decorator-state.types.js";
+import { type HttpVerb } from "./http-verbs.js";
+import type { RouteSchema } from "./openapi-builder.js";
+type MiddlewareParameter = any[] | any;
+type ControllerOptions = string | string[] | {
+    path: string | string[];
+};
+interface RootState {
+    paths: string[];
+    beforeMiddleware: any[];
+    afterMiddleware: any[];
+}
+interface MethodState {
+    paths: string[];
+    beforeMiddleware: any[];
+    afterMiddleware: any[];
+    verbs: HttpVerb[];
+    schema: RouteSchema;
+}
+export interface HttpDecoratorState extends DecoratorState<MethodState, RootState> {
+}
+export declare const HTTP_DECORATOR_STATE_TOKEN: DecoratorToken<HttpDecoratorState>;
+export declare const GET: (path?: string) => (target: any, context: ClassMethodDecoratorContext) => any;
+export declare const POST: (path?: string) => (target: any, context: ClassMethodDecoratorContext) => any;
+export declare const PUT: (path?: string) => (target: any, context: ClassMethodDecoratorContext) => any;
+export declare const DELETE: (path?: string) => (target: any, context: ClassMethodDecoratorContext) => any;
+export declare const PATCH: (path?: string) => (target: any, context: ClassMethodDecoratorContext) => any;
+export declare function controller(options?: ControllerOptions): (target: any, context: ClassDecoratorContext) => any;
+export declare function before(middleware: MiddlewareParameter): (target: any, context: ClassMethodDecoratorContext | ClassDecoratorContext) => any;
+export declare function after(middleware: MiddlewareParameter): (target: any, context: ClassMethodDecoratorContext | ClassDecoratorContext) => any;
+export declare function schema(schema: RouteSchema): (target: any, context: ClassMethodDecoratorContext) => any;
+export declare function rollUpHttpDecoratorState(root: RootState, method: MethodState): MethodState;
+export {};