stratal 0.0.1

package/dist/di/container.js

@@ -0,0 +1,466 @@
+import { LOGGER_TOKENS } from '../logger/logger.tokens';
+import { ConditionalBindingBuilderImpl } from './conditional-binding-builder';
+import { RequestScopeOperationNotAllowedError } from './errors/request-scope-operation-not-allowed.error';
+import { RequestContextStore } from './request-context-store';
+import { CONTAINER_TOKEN, DI_TOKENS } from './tokens';
+/**
+ * Unified Container for DI management
+ *
+ * Manages the two-tier container hierarchy:
+ * - Global scope: Singletons, base instances of request-scoped services
+ * - Request scope: Context-enriched instances per HTTP request
+ *
+ * @example Basic registration
+ * ```typescript
+ * import { container as tsyringeRootContainer } from 'tsyringe'
+ *
+ * const container = new Container({
+ *   env,
+ *   ctx,
+ *   container: tsyringeRootContainer.createChildContainer()
+ * })
+ *
+ * // Auto-extract token and scope from decorator
+ * container.register(I18nService)
+ *
+ * // Explicit token with auto-scope detection
+ * container.register(MY_TOKEN, MyService)
+ *
+ * // Explicit singleton registration
+ * container.registerSingleton(ConfigService)
+ *
+ * // Register a value
+ * container.registerValue(MY_TOKEN, myInstance)
+ * ```
+ *
+ * @example Resolution
+ * ```typescript
+ * // Resolves from container
+ * const service = container.resolve(MY_TOKEN)
+ * ```
+ *
+ * @example Request scope (automatic lifecycle)
+ * ```typescript
+ * await container.runInRequestScope(routerContext, async () => {
+ *   const i18n = container.resolve(I18N_TOKEN)
+ *   // i18n is context-enriched for this request
+ * })
+ * ```
+ *
+ * @example Request scope (manual lifecycle)
+ * ```typescript
+ * const reqContainer = container.createRequestScope(routerContext)
+ * reqContainer.registerValue(DI_TOKENS.TenantContext, tenantContext)
+ * await reqContainer.runWithContextStore(async () => {
+ *   // use reqContainer...
+ * })
+ * // Cleanup is automatic
+ * ```
+ */
+export class Container {
+    container;
+    contextStore;
+    env;
+    ctx;
+    isRequestScoped;
+    constructor(options) {
+        this.env = options.env;
+        this.ctx = options.ctx;
+        this.isRequestScoped = options.isRequestScoped ?? false;
+        this.contextStore = RequestContextStore.getInstance();
+        this.container = options.container;
+        // Only register bindings for global container (not request-scoped)
+        if (!this.isRequestScoped) {
+            this.container.register(DI_TOKENS.CloudflareEnv, { useValue: options.env });
+            this.container.register(DI_TOKENS.ExecutionContext, { useValue: options.ctx });
+            this.container.register(CONTAINER_TOKEN, { useValue: this });
+        }
+    }
+    get logger() {
+        return this.container.resolve(LOGGER_TOKENS.LoggerService);
+    }
+    register(tokenOrClass, serviceClassOrScope, scope) {
+        let token;
+        let serviceClass;
+        let lifecycle;
+        if (typeof serviceClassOrScope === 'function') {
+            // Called as register(token, class, scope?)
+            token = tokenOrClass;
+            serviceClass = serviceClassOrScope;
+            lifecycle = scope;
+        }
+        else {
+            // Called as register(class, scope?)
+            token = tokenOrClass;
+            serviceClass = tokenOrClass;
+            lifecycle = serviceClassOrScope;
+        }
+        if (lifecycle !== undefined) {
+            this.container.register(token, { useClass: serviceClass }, { lifecycle });
+        }
+        else {
+            this.container.register(token, { useClass: serviceClass });
+        }
+    }
+    registerSingleton(tokenOrClass, serviceClass) {
+        if (serviceClass !== undefined) {
+            this.container.registerSingleton(tokenOrClass, serviceClass);
+        }
+        else {
+            const targetClass = tokenOrClass;
+            this.container.registerSingleton(targetClass, targetClass);
+        }
+    }
+    /**
+     * Register a value (instance) directly
+     *
+     * Use for registering pre-created instances or primitive values.
+     *
+     * @param token - DI token for resolution
+     * @param value - Value to register
+     *
+     * @example
+     * ```typescript
+     * container.registerValue(CONFIG_TOKEN, configInstance)
+     * container.registerValue(DI_TOKENS.Application, app)
+     * ```
+     */
+    registerValue(token, value) {
+        this.container.register(token, { useValue: value });
+    }
+    /**
+     * Register with factory function
+     *
+     * Use when instance creation requires custom logic or other resolved dependencies.
+     *
+     * @param token - DI token for resolution
+     * @param factory - Factory function that receives the Container
+     * @param scope - Optional lifecycle scope (defaults to Transient)
+     *
+     * @example
+     * ```typescript
+     * container.registerFactory(FORMATTER_TOKEN, (c) => {
+     *   const config = c.resolve(CONFIG_TOKEN)
+     *   return config.get('logging').formatter === 'pretty'
+     *     ? new PrettyFormatter()
+     *     : new JsonFormatter()
+     * }, Scope.Singleton)
+     * ```
+     */
+    registerFactory(token, factory) {
+        this.container.register(token, { useFactory: () => factory(this) });
+    }
+    /**
+     * Register an alias to an existing token
+     *
+     * Creates a redirect so that resolving the alias token returns the same
+     * instance as the target token. This is useful for:
+     * - Interface tokens that alias concrete implementations
+     * - Multiple entry points to the same service
+     *
+     * @param alias - The alias token to register
+     * @param target - The target token to redirect to
+     *
+     * @example Interface abstraction
+     * ```typescript
+     * // Register concrete implementation
+     * container.register(UserService)
+     *
+     * // Create alias for interface token
+     * container.registerExisting(I_USER_SERVICE, UserService)
+     *
+     * // Both resolve to the same instance
+     * const a = container.resolve(UserService)
+     * const b = container.resolve(I_USER_SERVICE)
+     * // a === b (same instance)
+     * ```
+     */
+    registerExisting(alias, target) {
+        this.container.register(alias, { useToken: target });
+    }
+    // ============================================================
+    // Resolution Methods
+    // ============================================================
+    /**
+     * Resolve a service from the container
+     *
+     * @param token - DI token for the service
+     * @returns Resolved service instance
+     *
+     * @example
+     * ```typescript
+     * const logger = container.resolve(LOGGER_TOKEN)
+     * const config = container.resolve<IConfigService>(CONFIG_TOKEN)
+     * ```
+     */
+    resolve(token) {
+        return this.container.resolve(token);
+    }
+    /**
+     * Check if a token is registered
+     *
+     * @param token - DI token to check
+     * @returns true if token is registered
+     */
+    isRegistered(token) {
+        return this.container.isRegistered(token);
+    }
+    // ============================================================
+    // Conditional Registration Methods
+    // ============================================================
+    /**
+     * Start a conditional binding with predicate evaluation
+     *
+     * Creates a fluent builder for registering a service that chooses between
+     * two implementations based on a predicate evaluated at resolution time.
+     *
+     * @param predicate - Function that returns true/false to determine implementation.
+     *                    Receives a container with `resolve()` method for resolving dependencies.
+     * @param options - Optional configuration (cache: whether to cache predicate result)
+     * @returns Fluent builder for specifying token and implementations
+     *
+     * @example Environment-based implementation selection
+     * ```typescript
+     * container
+     *   .when((c) => c.resolve(CONFIG_TOKEN).get('env') === 'development')
+     *   .use(FORMATTER_TOKEN)
+     *   .give(PrettyFormatter)
+     *   .otherwise(JsonFormatter)
+     * ```
+     *
+     * @example Feature flag with cached predicate
+     * ```typescript
+     * container
+     *   .when((c) => c.resolve(FEATURE_FLAGS_TOKEN).isEnabled('newPaymentGateway'), { cache: true })
+     *   .use(PAYMENT_TOKEN)
+     *   .give(StripePaymentService)
+     *   .otherwise(LegacyPaymentService)
+     * ```
+     */
+    when(predicate, options = {}) {
+        return new ConditionalBindingBuilderImpl(this.container, this, predicate, options);
+    }
+    /**
+     * Replace a service registration with a decorated version
+     *
+     * Resolves the current instance, applies the decorator, and re-registers
+     * the decorated instance. This is a one-time operation at initialization time.
+     *
+     * **IMPORTANT:** This method can only be used in a module's `onInitialize()` method.
+     * The `onInitialize()` hook runs after all modules have registered their services
+     * via the `@Module` decorator, ensuring all dependencies are available for resolution.
+     *
+     * @param token - DI token of the service to extend
+     * @param decorator - Function that receives the service and returns decorated version
+     *
+     * @example Add logging to database service (in onInitialize)
+     * ```typescript
+     * // In your module's onInitialize() method:
+     * import type { OnInitialize, ModuleContext } from 'stratal/module'
+     *
+     * @Module({ providers: [...] })
+     * export class MyModule implements OnInitialize {
+     *   onInitialize({ container }: ModuleContext): void {
+     *     container.extend(DI_TOKENS.Database, (db, c) => {
+     *       const logger = c.resolve(LOGGER_TOKENS.LoggerService)
+     *       return new LoggingDatabaseDecorator(db, logger)
+     *     })
+     *   }
+     * }
+     * // DI_TOKENS.Database now resolves to LoggingDatabaseDecorator
+     * ```
+     *
+     * @example Chain multiple decorators
+     * ```typescript
+     * // In onInitialize()
+     * container.extend(SERVICE_TOKEN, (svc) => new LoggingDecorator(svc))
+     * container.extend(SERVICE_TOKEN, (svc) => new CachingDecorator(svc))
+     * // SERVICE_TOKEN now resolves to CachingDecorator(LoggingDecorator(original))
+     * ```
+     */
+    extend(token, decorator) {
+        // Resolve current instance
+        const currentInstance = this.container.resolve(token);
+        // Apply decorator
+        const decoratedInstance = decorator(currentInstance, this);
+        // Re-register with decorated instance (replaces existing registration)
+        this.container.register(token, { useValue: decoratedInstance });
+    }
+    // ============================================================
+    // Request Scope Management
+    // ============================================================
+    /**
+     * Check if currently in request context
+     *
+     * @returns true if in request context (inside runInRequestScope or runWithContextStore)
+     */
+    isInRequestContext() {
+        return this.contextStore.hasRequestContext();
+    }
+    /**
+     * Run callback within request scope
+     *
+     * Creates a child container with fresh instances for services registered with `scope: Scope.Request`.
+     * Automatically handles lifecycle (setup and cleanup).
+     *
+     * Also wraps with RequestContextStore for Zod i18n validation support.
+     *
+     * Can only be called on global container (not request-scoped).
+     *
+     * @param routerContext - RouterContext for the current request
+     * @param callback - Async operation to run with request context
+     * @returns Result of callback execution
+     *
+     * @example
+     * ```typescript
+     * await container.runInRequestScope(routerContext, async () => {
+     *   const i18n = container.resolve(I18N_TOKEN)
+     *   const message = i18n.t('common.welcome')
+     *   // ...
+     * })
+     * ```
+     */
+    async runInRequestScope(routerContext, callback) {
+        if (this.isRequestScoped) {
+            throw new RequestScopeOperationNotAllowedError('runInRequestScope');
+        }
+        const requestChildContainer = this.createRequestChildContainer(routerContext);
+        try {
+            // Wrap with contextStore for Zod i18n validation
+            return await this.contextStore.run(requestChildContainer, callback);
+        }
+        finally {
+            await this.cleanupRequestContainer(requestChildContainer);
+        }
+    }
+    /**
+     * Create request scope container
+     *
+     * Use when you need manual control over the request container lifecycle,
+     * typically in middleware. Returns a new Container instance wrapping
+     * a request-scoped child container.
+     *
+     * Can only be called on global container (not request-scoped).
+     *
+     * @param routerContext - RouterContext for the current request
+     * @returns Request-scoped Container instance
+     *
+     * @example
+     * ```typescript
+     * const reqContainer = container.createRequestScope(routerContext)
+     * reqContainer.registerValue(DI_TOKENS.TenantContext, tenantContext)
+     * await reqContainer.runWithContextStore(async () => {
+     *   // use reqContainer...
+     * })
+     * // Cleanup is automatic
+     * ```
+     */
+    createRequestScope(routerContext) {
+        if (this.isRequestScoped) {
+            throw new RequestScopeOperationNotAllowedError('createRequestScope');
+        }
+        const requestChildContainer = this.createRequestChildContainer(routerContext);
+        return new Container({
+            env: this.env,
+            ctx: this.ctx,
+            container: requestChildContainer,
+            isRequestScoped: true
+        });
+    }
+    /**
+     * Run callback within request scope context store
+     *
+     * Wraps callback with RequestContextStore (for Zod i18n validation)
+     * and automatically handles cleanup after callback completes.
+     *
+     * Can only be called on request-scoped container (not global).
+     *
+     * @param callback - Async operation to run with context
+     * @returns Result of callback execution
+     *
+     * @example
+     * ```typescript
+     * const reqContainer = container.createRequestScope(routerContext)
+     * reqContainer.registerValue(DI_TOKENS.TenantContext, tenantContext)
+     * await reqContainer.runWithContextStore(async () => {
+     *   const i18n = reqContainer.resolve(I18N_TOKENS.I18nService)
+     *   // ...
+     * })
+     * // Cleanup is automatic
+     * ```
+     */
+    async runWithContextStore(callback) {
+        if (!this.isRequestScoped) {
+            throw new RequestScopeOperationNotAllowedError('runWithContextStore');
+        }
+        try {
+            return await this.contextStore.run(this.container, callback);
+        }
+        finally {
+            await this.cleanupRequestContainer(this.container);
+        }
+    }
+    // ============================================================
+    // Escape Hatches
+    // ============================================================
+    /**
+     * Get underlying tsyringe container
+     *
+     * Use sparingly - prefer Container methods for most operations.
+     * Useful for advanced scenarios or compatibility with existing code.
+     * @returns The underlying DependencyContainer
+     */
+    getTsyringeContainer() {
+        return this.container;
+    }
+    /**
+     * Get current request container from context store (if in request context)
+     * @deprecated Use container.runWithContextStore() instead
+     * @returns Request container if in request context, undefined otherwise
+     */
+    getRequestContainer() {
+        return this.contextStore.getRequestContainer();
+    }
+    // ============================================================
+    // Private Methods
+    // ============================================================
+    /**
+     * Create request child container with RouterContext registered
+     *
+     * Services registered with `scope: Scope.Request` will automatically get fresh instances
+     * in the child container. RouterContext is registered so services can inject it for
+     * request-specific data.
+     */
+    createRequestChildContainer(routerContext) {
+        const requestContainer = this.container.createChildContainer();
+        // Register RouterContext in request container
+        // Services registered with scope: Scope.Request can inject this via DI_TOKENS.RouterContext
+        const ROUTER_TOKENS = { RouterContext: Symbol.for('RouterContext') };
+        requestContainer.register(ROUTER_TOKENS.RouterContext, { useValue: routerContext });
+        return requestContainer;
+    }
+    /**
+     * Cleanup request container (disconnect database, etc.)
+     *
+     * Disposes the ConnectionManager to close all database pools.
+     * This is called after each request to prevent connection leaks.
+     */
+    async cleanupRequestContainer(requestContainer) {
+        try {
+            if (requestContainer.isRegistered(DI_TOKENS.ConnectionManager)) {
+                const connectionManager = requestContainer.resolve(DI_TOKENS.ConnectionManager);
+                await connectionManager.dispose();
+            }
+        }
+        catch (error) {
+            this.logger.warn('Failed to dispose ConnectionManager', { error });
+        }
+    }
+    dispose() {
+        this.logger.info('Container disposed.');
+        return this.container.dispose();
+    }
+}
+// Re-export tsyringe utilities for convenience
+export { container, inject, injectable, singleton } from 'tsyringe';
+//# sourceMappingURL=container.js.map

package/dist/di/container.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.js","sourceRoot":"","sources":["../../src/di/container.ts"],"names":[],"mappings":"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"}

package/dist/di/decorators/inject-param.decorator.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Method Parameter Injection Decorator
+ *
+ * Enables DI for controller method parameters. Parameters marked with
+ * @InjectParam(token) are resolved from the request-scoped container
+ * at method invocation time.
+ *
+ * @example
+ * ```typescript
+ * @Route({ response: userSchema })
+ * async show(
+ *   ctx: RouterContext,
+ *   @InjectParam(UserService) userService: UserService,
+ *   @InjectParam(CacheService) cache: CacheService
+ * ): Promise<Response> {
+ *   // userService and cache auto-resolved from request container
+ * }
+ * ```
+ */
+import type InjectionToken from 'tsyringe/dist/typings/providers/injection-token';
+/**
+ * Metadata key for storing parameter injection information
+ */
+export declare const INJECT_PARAM_METADATA_KEY: unique symbol;
+/**
+ * Describes a parameter injection
+ */
+export interface ParamInjection {
+    /** Parameter index in the method signature (0-based) */
+    index: number;
+    /** DI token to resolve */
+    token: InjectionToken;
+}
+/**
+ * Mark a method parameter for DI injection
+ *
+ * The parameter will be resolved from the request-scoped container
+ * when the controller method is invoked.
+ *
+ * @param token - DI token to resolve (class or symbol)
+ *
+ * @example With class token
+ * ```typescript
+ * async show(
+ *   ctx: RouterContext,
+ *   @InjectParam(UserService) userService: UserService
+ * ) { }
+ * ```
+ *
+ * @example With symbol token
+ * ```typescript
+ * async show(
+ *   ctx: RouterContext,
+ *   @InjectParam(DI_TOKENS.Cache) cache: ICacheService
+ * ) { }
+ * ```
+ */
+export declare function InjectParam<T>(token: InjectionToken<T>): ParameterDecorator;
+/**
+ * Get method parameter injections
+ *
+ * @param target - Controller prototype
+ * @param propertyKey - Method name
+ * @returns Array of parameter injections sorted by index
+ */
+export declare function getMethodInjections(target: object, propertyKey: string | symbol): ParamInjection[];
+//# sourceMappingURL=inject-param.decorator.d.ts.map

package/dist/di/decorators/inject-param.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-param.decorator.d.ts","sourceRoot":"","sources":["../../../src/di/decorators/inject-param.decorator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,cAAc,MAAM,iDAAiD,CAAA;AAEjF;;GAEG;AACH,eAAO,MAAM,yBAAyB,eAAyB,CAAA;AAE/D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAA;IACb,0BAA0B;IAC1B,KAAK,EAAE,cAAc,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAgB3E;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,EAAE,CAKlG"}

package/dist/di/decorators/inject-param.decorator.js

@@ -0,0 +1,53 @@
+/**
+ * Metadata key for storing parameter injection information
+ */
+export const INJECT_PARAM_METADATA_KEY = Symbol('inject:param');
+/**
+ * Mark a method parameter for DI injection
+ *
+ * The parameter will be resolved from the request-scoped container
+ * when the controller method is invoked.
+ *
+ * @param token - DI token to resolve (class or symbol)
+ *
+ * @example With class token
+ * ```typescript
+ * async show(
+ *   ctx: RouterContext,
+ *   @InjectParam(UserService) userService: UserService
+ * ) { }
+ * ```
+ *
+ * @example With symbol token
+ * ```typescript
+ * async show(
+ *   ctx: RouterContext,
+ *   @InjectParam(DI_TOKENS.Cache) cache: ICacheService
+ * ) { }
+ * ```
+ */
+export function InjectParam(token) {
+    return (target, propertyKey, parameterIndex) => {
+        if (propertyKey === undefined) {
+            throw new Error('@InjectParam can only be used on method parameters, not constructor parameters');
+        }
+        const existingInjections = Reflect.getMetadata(INJECT_PARAM_METADATA_KEY, target, propertyKey) ?? [];
+        existingInjections.push({
+            index: parameterIndex,
+            token,
+        });
+        Reflect.defineMetadata(INJECT_PARAM_METADATA_KEY, existingInjections, target, propertyKey);
+    };
+}
+/**
+ * Get method parameter injections
+ *
+ * @param target - Controller prototype
+ * @param propertyKey - Method name
+ * @returns Array of parameter injections sorted by index
+ */
+export function getMethodInjections(target, propertyKey) {
+    const injections = Reflect.getMetadata(INJECT_PARAM_METADATA_KEY, target, propertyKey) ?? [];
+    return injections.sort((a, b) => a.index - b.index);
+}
+//# sourceMappingURL=inject-param.decorator.js.map

package/dist/di/decorators/inject-param.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-param.decorator.js","sourceRoot":"","sources":["../../../src/di/decorators/inject-param.decorator.ts"],"names":[],"mappings":"AAqBA;;GAEG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC,cAAc,CAAC,CAAA;AAY/D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,WAAW,CAAI,KAAwB;IACrD,OAAO,CAAC,MAAc,EAAE,WAAwC,EAAE,cAAsB,EAAE,EAAE;QAC1F,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAA;QACnG,CAAC;QAED,MAAM,kBAAkB,GACrB,OAAO,CAAC,WAAW,CAAC,yBAAyB,EAAE,MAAM,EAAE,WAAW,CAAkC,IAAI,EAAE,CAAA;QAE7G,kBAAkB,CAAC,IAAI,CAAC;YACtB,KAAK,EAAE,cAAc;YACrB,KAAK;SACN,CAAC,CAAA;QAEF,OAAO,CAAC,cAAc,CAAC,yBAAyB,EAAE,kBAAkB,EAAE,MAAM,EAAE,WAAW,CAAC,CAAA;IAC5F,CAAC,CAAA;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAc,EAAE,WAA4B;IAC9E,MAAM,UAAU,GACb,OAAO,CAAC,WAAW,CAAC,yBAAyB,EAAE,MAAM,EAAE,WAAW,CAAkC,IAAI,EAAE,CAAA;IAE7G,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAA;AACrD,CAAC"}

package/dist/di/decorators.d.ts

@@ -0,0 +1,57 @@
+import type InjectionToken from 'tsyringe/dist/typings/providers/injection-token';
+export { InjectParam, getMethodInjections, type ParamInjection, INJECT_PARAM_METADATA_KEY, } from './decorators/inject-param.decorator';
+/**
+ * Mark a class as injectable
+ *
+ * This decorator wraps tsyringe's @injectable decorator and optionally
+ * associates a token with the class. The actual lifecycle (Singleton, Request,
+ * Transient) is determined at registration time, not decoration time.
+ *
+ * **Lifecycle Control:**
+ * - Use `scope: Scope.Singleton` in module providers for singleton
+ * - Use `scope: Scope.Request` in module providers for request-scoped
+ * - Default is Transient (new instance per resolution)
+ *
+ * @param token - Optional DI token for service resolution
+ *
+ * @example Basic usage (no token)
+ * ```typescript
+ * @Transient()
+ * export class UserService {
+ *   constructor(@inject(DI_TOKENS.Database) private db: DatabaseService) {}
+ * }
+ *
+ * // In module:
+ * @Module({
+ *   providers: [UserService]  // Transient by default
+ * })
+ * ```
+ *
+ * @example With token
+ * ```typescript
+ * @Transient(DI_TOKENS.ConnectionManager)
+ * export class ConnectionManager implements Disposable {
+ *   // ...
+ * }
+ *
+ * // In Application.ts:
+ * container.register(DI_TOKENS.ConnectionManager, ConnectionManager, Scope.Request)
+ * ```
+ *
+ * @example Singleton via provider scope
+ * ```typescript
+ * @Transient()
+ * export class ConsumerRegistry {
+ *   // ...
+ * }
+ *
+ * // In module:
+ * @Module({
+ *   providers: [
+ *     { provide: DI_TOKENS.ConsumerRegistry, useClass: ConsumerRegistry, scope: Scope.Singleton }
+ *   ]
+ * })
+ * ```
+ */
+export declare function Transient<T>(token?: InjectionToken<T>): <TFunction extends abstract new (...args: never[]) => unknown>(target: TFunction) => TFunction;
+//# sourceMappingURL=decorators.d.ts.map

package/dist/di/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../src/di/decorators.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,cAAc,MAAM,iDAAiD,CAAA;AAGjF,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,KAAK,cAAc,EACnB,yBAAyB,GAC1B,MAAM,qCAAqC,CAAA;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,IACnC,SAAS,SAAS,QAAQ,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EAAE,QAAQ,SAAS,KAAG,SAAS,CAK7G"}