opinionated-machine 6.9.0 → 6.10.0

package/README.md

@@ -4,6 +4,8 @@ Very opinionated DI framework for fastify, built on top of awilix
 ## Table of Contents
 
 - [Basic usage](#basic-usage)
+  - [Managing global public dependencies across modules](#managing-global-public-dependencies-across-modules)
+  - [Avoiding circular dependencies in typed cradle parameters](#avoiding-circular-dependencies-in-typed-cradle-parameters)
 - [Defining controllers](#defining-controllers)
 - [Putting it all together](#putting-it-all-together)
 - [Resolver Functions](#resolver-functions)
@@ -124,13 +126,274 @@ export type ModuleDependencies = InferModuleDependencies<MyModule>
 
 The `InferModuleDependencies` utility type extracts the dependency types from the resolvers returned by `resolveDependencies()`, so you don't need to maintain a separate type manually.
 
-When a module is used as a secondary module, only resolvers marked as **public** (`asServiceClass`, `asUseCaseClass`, `asJobQueueClass`, `asEnqueuedJobQueueManagerFunction`) are exposed. Use `InferPublicModuleDependencies` to infer only the public dependencies:
+When a module is used as a secondary module, only resolvers marked as **public** (`asServiceClass`, `asUseCaseClass`, `asJobQueueClass`, `asEnqueuedJobQueueManagerFunction`) are exposed. Use `InferPublicModuleDependencies` to infer only the public dependencies (private ones are omitted entirely):
 
 ```ts
-// Inferred as { service: Service } — repositories and other private resolvers are excluded
+// Inferred as { service: Service } — private resolvers are omitted
 export type MyModulePublicDependencies = InferPublicModuleDependencies<MyModule>
 ```
 
+### Managing global public dependencies across modules
+
+When your application has multiple secondary modules, you need a single type that combines all their public dependencies. The library exports an empty `PublicDependencies` interface that each module can augment via TypeScript's [module augmentation](https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation). Each module file adds its own public deps to this shared interface using `declare module`. The augmentations are **project-wide** — they apply everywhere as long as the augmenting file is part of your TypeScript compilation (included in `tsconfig.json`), with no explicit import chain required.
+
+Start with a `CommonModule` that provides shared infrastructure dependencies (logger, config, etc.), then add domain modules that each augment the same interface independently.
+
+```ts
+// CommonModule.ts — shared infrastructure
+import { AbstractModule, type InferPublicModuleDependencies } from 'opinionated-machine'
+
+export class CommonModule extends AbstractModule {
+  resolveDependencies(diOptions: DependencyInjectionOptions) {
+    return {
+      config: asSingletonFunction(() => loadConfig()),     // private — omitted
+      logger: asServiceClass(Logger),                      // public
+      eventEmitter: asServiceClass(AppEventEmitter),       // public
+    }
+  }
+}
+
+declare module 'opinionated-machine' {
+  interface PublicDependencies extends InferPublicModuleDependencies<CommonModule> {}
+}
+```
+
+```ts
+// UsersModule.ts — no need to import CommonModule's type
+import { AbstractModule, type InferPublicModuleDependencies } from 'opinionated-machine'
+
+export class UsersModule extends AbstractModule {
+  resolveDependencies(diOptions: DependencyInjectionOptions) {
+    return {
+      userService: asServiceClass(UserService),         // public
+      userRepository: asRepositoryClass(UserRepository), // private — omitted
+    }
+  }
+}
+
+declare module 'opinionated-machine' {
+  interface PublicDependencies extends InferPublicModuleDependencies<UsersModule> {}
+}
+```
+
+```ts
+// BillingModule.ts — independent, no chain
+import { AbstractModule, type InferPublicModuleDependencies } from 'opinionated-machine'
+
+export class BillingModule extends AbstractModule {
+  resolveDependencies(diOptions: DependencyInjectionOptions) {
+    return {
+      billingService: asServiceClass(BillingService),       // public
+      paymentGateway: asRepositoryClass(PaymentGateway),     // private — omitted
+    }
+  }
+}
+
+declare module 'opinionated-machine' {
+  interface PublicDependencies extends InferPublicModuleDependencies<BillingModule> {}
+}
+```
+
+Importing `PublicDependencies` from anywhere gives you the full accumulated type: `{ logger: Logger; eventEmitter: AppEventEmitter; userService: UserService; billingService: BillingService }`. Private dependencies (`config`, `userRepository`, `paymentGateway`) are omitted automatically. No explicit import chain between modules is needed — each module augments the interface independently.
+
+#### Typing constructor dependencies within a module
+
+Classes within a module can access both the module's own dependencies (including private ones like repositories) and all public dependencies from other modules. Combine `InferModuleDependencies` with `PublicDependencies` to get the full cradle type available at runtime:
+
+```ts
+// UsersModule.ts
+import {
+  AbstractModule,
+  type InferModuleDependencies,
+  type InferPublicModuleDependencies,
+  type PublicDependencies,
+} from 'opinionated-machine'
+
+// Module's own deps (public + private) merged with all public deps from other modules
+type UsersModuleInjectables = InferModuleDependencies<UsersModule> & PublicDependencies
+
+export class UserService {
+  private readonly repository: UserRepository
+  private readonly logger: Logger  // from CommonModule's public deps
+
+  constructor(dependencies: UsersModuleInjectables) {
+    this.repository = dependencies.userRepository  // own private dep — accessible
+    this.logger = dependencies.logger              // public dep from another module — accessible
+    // dependencies.billingRepository              // private dep from another module — type error
+  }
+}
+
+class UserRepository {}
+
+export class UsersModule extends AbstractModule {
+  resolveDependencies(diOptions: DependencyInjectionOptions) {
+    return {
+      userService: asServiceClass(UserService),
+      userRepository: asRepositoryClass(UserRepository),
+    }
+  }
+}
+
+declare module 'opinionated-machine' {
+  interface PublicDependencies extends InferPublicModuleDependencies<UsersModule> {}
+}
+```
+
+This gives each class access to exactly what the DI container provides at runtime: the module's own registered dependencies plus all public dependencies from secondary modules. Private dependencies from other modules are excluded at the type level, matching the runtime behavior.
+
+#### Constructing the combined dependency type for `DIContext`
+
+Use `PublicDependencies` when building the full dependency type:
+
+```ts
+import type { PublicDependencies } from 'opinionated-machine'
+
+type Dependencies = InferModuleDependencies<PrimaryModule> & PublicDependencies
+```
+
+### Avoiding circular dependencies in typed cradle parameters
+
+Because `InferModuleDependencies` is inferred from the module's own `resolveDependencies()` return type, classes and functions that reference it inside the same module could create a circular type dependency. The library handles this automatically for class-based resolvers. For function-based resolvers, use the indexed access pattern described below.
+
+#### Class-based resolvers (recommended — works automatically)
+
+All class-based resolver functions (`asSingletonClass`, `asServiceClass`, `asRepositoryClass`, etc.) use a `ClassValue<T>` type internally, which infers the instance type from the class's `prototype` property rather than its constructor signature. This means classes can freely reference `InferModuleDependencies` in their constructors without causing circular type dependencies:
+
+```ts
+import { AbstractModule, type InferModuleDependencies, asServiceClass, asSingletonClass } from 'opinionated-machine'
+
+export class MyService {
+  // Constructor references ModuleDependencies — no circular dependency!
+  constructor({ myHelper }: ModuleDependencies) {
+    // myHelper is fully typed as MyHelper
+  }
+}
+
+export class MyHelper {
+  process() {}
+}
+
+export class MyModule extends AbstractModule {
+  resolveDependencies(diOptions: DependencyInjectionOptions) {
+    return {
+      myService: asServiceClass(MyService),   // ClassValue<T> breaks the cycle
+      myHelper: asSingletonClass(MyHelper),
+    }
+  }
+}
+
+export type ModuleDependencies = InferModuleDependencies<MyModule>
+```
+
+**Prefer class-based resolvers wherever possible** — they provide full type safety with no `any` fallback and no extra annotations needed.
+
+#### Function-based resolvers (`asSingletonFunction`)
+
+Function-based resolvers (`asSingletonFunction`) cannot use the `ClassValue<T>` trick because functions don't have a `prototype` property that separates return type from parameter types. Use **indexed access** on `InferModuleDependencies` to type individual dependencies without triggering a circular reference:
+
+```ts
+// Inside resolveDependencies():
+myHelper: asSingletonClass(MyHelper),
+myService: asServiceClass(MyService),
+
+myFactory: asSingletonFunction(
+  ({ myHelper, myService }: {
+    myHelper: ModuleDependencies['myHelper']
+    myService: ModuleDependencies['myService']
+  }) => {
+    return () => myHelper.process()
+  },
+),
+
+// ...
+
+// At the bottom of the file:
+export type ModuleDependencies = InferModuleDependencies<MyModule>
+```
+
+This works because TypeScript resolves indexed access types (`ModuleDependencies['myHelper']`) **lazily** — it looks up individual properties without computing the entire `ModuleDependencies` type, avoiding the cycle. Each dependency is fully typed and stays in sync with the module's resolvers automatically. No explicit return type annotation is needed.
+
+For cross-module dependencies, use `InferPublicModuleDependencies`:
+
+```ts
+type OtherDeps = InferPublicModuleDependencies<OtherModule>
+
+myFactory: asSingletonFunction(
+  ({ externalService }: { externalService: OtherDeps['externalService'] }) => {
+    return new MyFactory(externalService)
+  },
+),
+```
+
+**Note:** `Pick<ModuleDependencies, 'a' | 'b'>` does **not** work — `Pick` requires `keyof ModuleDependencies`, which forces TypeScript to resolve the entire type and triggers the circular reference. Each property must be accessed individually via indexed access.
+
+**Alternative: class wrapper**
+
+When adapting a third-party class with an incompatible constructor, `asSingletonFunction` is typically used to bridge the gap between the DI cradle and the library's API. If the adapter needs many dependencies, the indexed access syntax can become verbose. In that case, wrap the adaptation logic in a class and use `asSingletonClass` instead — the constructor can reference `ModuleDependencies` directly since `ClassValue<T>` breaks the cycle automatically:
+
+```ts
+// Third-party library — constructor is incompatible with DI cradle
+import { S3Client } from '@aws-sdk/client-s3'
+
+// With asSingletonFunction, each dep needs indexed access:
+s3Client: asSingletonFunction(
+  ({ config, logger }: {
+    config: ModuleDependencies['config']
+    logger: ModuleDependencies['logger']
+  }) => {
+    return new S3Client({
+      region: config.awsRegion,
+      credentials: { accessKeyId: config.awsAccessKey, secretAccessKey: config.awsSecretKey },
+      logger,
+    })
+  },
+),
+
+// With a class wrapper, reference ModuleDependencies directly.
+// If you need to add domain-specific methods, the wrapper becomes a full adapter:
+class S3StorageAdapter {
+  private readonly client: S3Client
+
+  constructor({ config, logger }: ModuleDependencies) {
+    this.client = new S3Client({
+      region: config.awsRegion,
+      credentials: { accessKeyId: config.awsAccessKey, secretAccessKey: config.awsSecretKey },
+      logger,
+    })
+  }
+
+  async upload(bucket: string, key: string, body: Buffer): Promise<string> {
+    await this.client.send(new PutObjectCommand({ Bucket: bucket, Key: key, Body: body }))
+    return `https://${bucket}.s3.amazonaws.com/${key}`
+  }
+}
+
+// In resolveDependencies():
+s3StorageAdapter: asSingletonClass(S3StorageAdapter),
+
+// If you just need the third-party instance as-is without adding any logic,
+// use a simple container to avoid re-wrapping every method:
+class S3ClientProvider {
+  readonly client: S3Client
+
+  constructor({ config, logger }: ModuleDependencies) {
+    this.client = new S3Client({
+      region: config.awsRegion,
+      credentials: { accessKeyId: config.awsAccessKey, secretAccessKey: config.awsSecretKey },
+      logger,
+    })
+  }
+}
+
+// In resolveDependencies():
+s3ClientProvider: asSingletonClass(S3ClientProvider),
+
+// Consumers access the original instance directly:
+// this.s3ClientProvider.client.send(new PutObjectCommand({ ... }))
+```
+
+This is more heavyweight than a function resolver but provides full type safety with no indexed access needed, and scales cleanly to any number of dependencies.
+
 You can also use the explicit generic pattern if you prefer (e.g. for `isolatedDeclarations` mode):
 
 ```ts

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { AbstractController, type BuildRoutesReturnType } from './lib/AbstractController.js';
-export { AbstractModule, type InferModuleDependencies, type InferPublicModuleDependencies, type MandatoryNameAndRegistrationPair, type UnionToIntersection, } from './lib/AbstractModule.js';
+export { AbstractModule, type InferModuleDependencies, type InferPublicModuleDependencies, type MandatoryNameAndRegistrationPair, type PublicDependencies, } from './lib/AbstractModule.js';
 export { AbstractTestContextFactory, type CreateTestContextParams, } from './lib/AbstractTestContextFactory.js';
 export type { NestedPartial } from './lib/configUtils.js';
 export { type DependencyInjectionOptions, DIContext, type RegisterDependenciesParams, } from './lib/DIContext.js';

package/dist/lib/AbstractModule.d.ts

@@ -3,10 +3,6 @@ import type { DependencyInjectionOptions } from './DIContext.js';
 export type MandatoryNameAndRegistrationPair<T> = {
     [U in keyof T]: Resolver<T[U]>;
 };
-/**
- * Use this utility type to combine dependencies from multiple modules into full context list of dependencies
- */
-export type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
 /**
  * Infers the module's dependency types from the return type of `resolveDependencies()`.
  *
@@ -32,20 +28,20 @@ export type InferModuleDependencies<M extends AbstractModule> = ReturnType<M['re
     [K in keyof R]: R[K] extends Resolver<infer T> ? T : never;
 } : never;
 /**
- * Infers only the **public** dependency types from the return type of `resolveDependencies()`.
+ * Infers only the **public** dependency types from the return type of `resolveDependencies()`,
+ * omitting non-public dependencies entirely.
  *
  * When a module is used as a secondary module, only resolvers marked with `public: true`
  * (i.e. those created via `asServiceClass`, `asUseCaseClass`, `asJobQueueClass`, or
- * `asEnqueuedJobQueueManagerFunction`) are exposed. This type automatically filters
- * to just those public dependencies.
+ * `asEnqueuedJobQueueManagerFunction`) are exposed. Non-public resolvers are filtered out.
  *
  * @example
  * ```typescript
  * export class MyModule extends AbstractModule {
  *   resolveDependencies(diOptions: DependencyInjectionOptions) {
  *     return {
- *       myService: asServiceClass(MyService),       // public
- *       myRepo: asRepositoryClass(MyRepository),     // private
+ *       myService: asServiceClass(MyService),       // public → MyService
+ *       myRepo: asRepositoryClass(MyRepository),     // private → omitted
  *     }
  *   }
  * }
@@ -59,6 +55,28 @@ export type InferPublicModuleDependencies<M extends AbstractModule> = ReturnType
         readonly __publicResolver: true;
     } ? K : never]: R[K] extends Resolver<infer T> ? T : never;
 } : never;
+/**
+ * Augmentation target for accumulating public dependencies across modules.
+ *
+ * Each module augments this interface via `declare module` to register its
+ * public dependencies. The augmentations are project-wide — they apply
+ * everywhere as long as the augmenting file is part of the TypeScript
+ * compilation, with no explicit import chain required.
+ *
+ * @example
+ * ```typescript
+ * // In your module file:
+ * declare module 'opinionated-machine' {
+ *   interface PublicDependencies extends InferPublicModuleDependencies<MyModule> {}
+ * }
+ *
+ * // In any consumer file:
+ * import type { PublicDependencies } from 'opinionated-machine'
+ * // PublicDependencies contains all augmented public deps
+ * ```
+ */
+export interface PublicDependencies {
+}
 export declare abstract class AbstractModule<ModuleDependencies = unknown, ExternalDependencies = never> {
     abstract resolveDependencies(diOptions: DependencyInjectionOptions, externalDependencies: ExternalDependencies): MandatoryNameAndRegistrationPair<ModuleDependencies>;
     /**

package/dist/lib/AbstractModule.js.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractModule.js","sourceRoot":"","sources":["../../lib/AbstractModule.ts"],"names":[],"mappings":"AAwEA,MAAM,OAAgB,cAAc;IAMlC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,kBAAkB,CACvB,UAAsC;QAEtC,OAAO,EAAE,CAAA;IACX,CAAC;CACF"}
+{"version":3,"file":"AbstractModule.js","sourceRoot":"","sources":["../../lib/AbstractModule.ts"],"names":[],"mappings":"AAwFA,MAAM,OAAgB,cAAc;IAMlC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,kBAAkB,CACvB,UAAsC;QAEtC,OAAO,EAAE,CAAA;IACX,CAAC;CACF"}

package/dist/lib/resolverFunctions.d.ts

@@ -1,6 +1,21 @@
-import type { BuildResolver, BuildResolverOptions, Constructor, DisposableResolver } from 'awilix';
+import type { BuildResolver, BuildResolverOptions, DisposableResolver } from 'awilix';
 import type { FunctionReturning } from 'awilix/lib/container';
 import type { DependencyInjectionOptions } from './DIContext.js';
+/**
+ * Type-level representation of a class value that infers the instance type
+ * from the `prototype` property rather than from the constructor signature.
+ *
+ * This breaks circular type dependencies that occur when a class constructor
+ * references a type derived from the module's own resolver return type
+ * (e.g. `InferModuleDependencies`), because TypeScript can resolve the
+ * instance type (prototype) without evaluating constructor parameter types.
+ *
+ * Constructor parameter types are still fully checked — the cycle is only
+ * broken at the resolver inference level.
+ */
+type ClassValue<T> = {
+    prototype: T;
+};
 declare module 'awilix' {
     interface ResolverOptions<T> {
         public?: boolean;
@@ -14,10 +29,10 @@ export type PublicResolver<T> = BuildResolver<T> & DisposableResolver<T> & {
 export interface EnqueuedJobQueueManager {
     start(enabled?: string[] | boolean): Promise<void>;
 }
-export declare function asSingletonClass<T = object>(Type: Constructor<T>, opts: BuildResolverOptions<T> & {
+export declare function asSingletonClass<T = object>(Type: ClassValue<T>, opts: BuildResolverOptions<T> & {
     public: true;
 }): PublicResolver<T>;
-export declare function asSingletonClass<T = object>(Type: Constructor<T>, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
+export declare function asSingletonClass<T = object>(Type: ClassValue<T>, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
 /**
  * Register a class with an additional config parameter passed to the constructor.
  * Uses asFunction wrapper internally to pass the config as a second parameter.
@@ -28,21 +43,21 @@ export declare function asSingletonClass<T = object>(Type: Constructor<T>, opts?
  * myService: asClassWithConfig(MyService, { enableFeature: true }),
  * ```
  */
-export declare function asClassWithConfig<T = object, Config = unknown>(Type: Constructor<T>, config: Config, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
+export declare function asClassWithConfig<T = object, Config = unknown>(Type: ClassValue<T>, config: Config, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
 export declare function asSingletonFunction<T>(fn: FunctionReturning<T>, opts: BuildResolverOptions<T> & {
     public: true;
 }): PublicResolver<T>;
 export declare function asSingletonFunction<T>(fn: FunctionReturning<T>, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
-export declare function asServiceClass<T = object>(Type: Constructor<T>, opts: BuildResolverOptions<T> & {
+export declare function asServiceClass<T = object>(Type: ClassValue<T>, opts: BuildResolverOptions<T> & {
     public: false;
 }): BuildResolver<T> & DisposableResolver<T>;
-export declare function asServiceClass<T = object>(Type: Constructor<T>, opts?: BuildResolverOptions<T>): PublicResolver<T>;
-export declare function asUseCaseClass<T = object>(Type: Constructor<T>, opts: BuildResolverOptions<T> & {
+export declare function asServiceClass<T = object>(Type: ClassValue<T>, opts?: BuildResolverOptions<T>): PublicResolver<T>;
+export declare function asUseCaseClass<T = object>(Type: ClassValue<T>, opts: BuildResolverOptions<T> & {
     public: false;
 }): BuildResolver<T> & DisposableResolver<T>;
-export declare function asUseCaseClass<T = object>(Type: Constructor<T>, opts?: BuildResolverOptions<T>): PublicResolver<T>;
-export declare function asRepositoryClass<T = object>(Type: Constructor<T>, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
-export declare function asControllerClass<T = object>(Type: Constructor<T>, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
+export declare function asUseCaseClass<T = object>(Type: ClassValue<T>, opts?: BuildResolverOptions<T>): PublicResolver<T>;
+export declare function asRepositoryClass<T = object>(Type: ClassValue<T>, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
+export declare function asControllerClass<T = object>(Type: ClassValue<T>, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
 export type SSEControllerModuleOptions = {
     diOptions: DependencyInjectionOptions;
 };
@@ -64,7 +79,7 @@ export type SSEControllerModuleOptions = {
  * notificationsSSEController: asSSEControllerClass(NotificationsSSEController, { diOptions }),
  * ```
  */
-export declare function asSSEControllerClass<T = object>(Type: Constructor<T>, sseOptions?: SSEControllerModuleOptions, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
+export declare function asSSEControllerClass<T = object>(Type: ClassValue<T>, sseOptions?: SSEControllerModuleOptions, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
 export type DualModeControllerModuleOptions = {
     diOptions: DependencyInjectionOptions;
 };
@@ -87,17 +102,17 @@ export type DualModeControllerModuleOptions = {
  * chatController: asDualModeControllerClass(ChatController, { diOptions }),
  * ```
  */
-export declare function asDualModeControllerClass<T = object>(Type: Constructor<T>, dualModeOptions?: DualModeControllerModuleOptions, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
+export declare function asDualModeControllerClass<T = object>(Type: ClassValue<T>, dualModeOptions?: DualModeControllerModuleOptions, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
 export type MessageQueueConsumerModuleOptions = {
     queueName: string;
     diOptions: DependencyInjectionOptions;
 };
-export declare function asMessageQueueHandlerClass<T = object>(Type: Constructor<T>, mqOptions: MessageQueueConsumerModuleOptions, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
+export declare function asMessageQueueHandlerClass<T = object>(Type: ClassValue<T>, mqOptions: MessageQueueConsumerModuleOptions, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
 export type EnqueuedJobWorkerModuleOptions = {
     queueName: string;
     diOptions: DependencyInjectionOptions;
 };
-export declare function asEnqueuedJobWorkerClass<T = object>(Type: Constructor<T>, workerOptions: EnqueuedJobWorkerModuleOptions, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
+export declare function asEnqueuedJobWorkerClass<T = object>(Type: ClassValue<T>, workerOptions: EnqueuedJobWorkerModuleOptions, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
 /**
  * Helper function to register a pg-boss job processor class with the DI container.
  * Handles asyncInit/asyncDispose lifecycle and enabled check based on diOptions.
@@ -113,21 +128,22 @@ export declare function asEnqueuedJobWorkerClass<T = object>(Type: Constructor<T
 export declare function asPgBossProcessorClass<T extends {
     start(): Promise<void>;
     stop(): Promise<void>;
-}>(Type: Constructor<T>, processorOptions: EnqueuedJobWorkerModuleOptions, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
+}>(Type: ClassValue<T>, processorOptions: EnqueuedJobWorkerModuleOptions, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
 export type PeriodicJobOptions = {
     jobName: string;
     diOptions: DependencyInjectionOptions;
 };
-export declare function asPeriodicJobClass<T = object>(Type: Constructor<T>, workerOptions: PeriodicJobOptions, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
+export declare function asPeriodicJobClass<T = object>(Type: ClassValue<T>, workerOptions: PeriodicJobOptions, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
 export type JobQueueModuleOptions = {
     queueName?: string;
     diOptions: DependencyInjectionOptions;
 };
-export declare function asJobQueueClass<T = object>(Type: Constructor<T>, queueOptions: JobQueueModuleOptions, opts: BuildResolverOptions<T> & {
+export declare function asJobQueueClass<T = object>(Type: ClassValue<T>, queueOptions: JobQueueModuleOptions, opts: BuildResolverOptions<T> & {
     public: false;
 }): BuildResolver<T> & DisposableResolver<T>;
-export declare function asJobQueueClass<T = object>(Type: Constructor<T>, queueOptions: JobQueueModuleOptions, opts?: BuildResolverOptions<T>): PublicResolver<T>;
+export declare function asJobQueueClass<T = object>(Type: ClassValue<T>, queueOptions: JobQueueModuleOptions, opts?: BuildResolverOptions<T>): PublicResolver<T>;
 export declare function asEnqueuedJobQueueManagerFunction<T extends EnqueuedJobQueueManager>(fn: FunctionReturning<T>, diOptions: DependencyInjectionOptions, opts: BuildResolverOptions<T> & {
     public: false;
 }): BuildResolver<T> & DisposableResolver<T>;
 export declare function asEnqueuedJobQueueManagerFunction<T extends EnqueuedJobQueueManager>(fn: FunctionReturning<T>, diOptions: DependencyInjectionOptions, opts?: BuildResolverOptions<T>): PublicResolver<T>;
+export {};

package/dist/lib/resolverFunctions.js

@@ -17,8 +17,9 @@ export function asSingletonClass(Type, opts) {
  * ```
  */
 export function asClassWithConfig(Type, config, opts) {
+    const Ctor = Type;
     // biome-ignore lint/suspicious/noExplicitAny: Dynamic constructor invocation with cradle proxy
-    return asFunction((cradle) => new Type(cradle, config), {
+    return asFunction((cradle) => new Ctor(cradle, config), {
         ...opts,
         lifetime: opts?.lifetime ?? 'SINGLETON',
     });

package/dist/lib/resolverFunctions.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "opinionated-machine",
-    "version": "6.9.0",
+    "version": "6.10.0",
     "description": "Very opinionated DI framework for fastify, built on top of awilix ",
     "type": "module",
     "license": "MIT",