inwire 2.2.1 → 2.3.0

package/README.md

@@ -301,6 +301,101 @@ const full = withDb.module((b) =>
 
 `module()` uses the builder internally for typed `c`, then delegates to `extend()`. Works on `scope()` and `extend()` results too.
 
+#### Deriving the container shape (Zod-style)
+
+You don't need to maintain a manual interface for the container's full shape. Derive it from the container itself, exactly like `z.infer<typeof schema>`:
+
+```typescript
+// container.ts
+import { container } from 'inwire';
+import { authModule } from './modules/auth.module';
+import { billingModule } from './modules/billing.module';
+import { persistenceModule } from './modules/persistence.module';
+
+export const di = container()
+  .addModule(persistenceModule)
+  .addModule(authModule)
+  .addModule(billingModule)
+  .build();
+
+// Single source of truth — derived, never written by hand.
+// Use this as the type for handlers, controllers, etc.
+export type Di = typeof di;
+```
+
+> Note: `Di` is your own type alias, not the global `AppDeps` interface inwire exports for the Pinia-style pattern below. They serve different purposes — `Di` is consumed by your code; `AppDeps` augments inwire's typing.
+
+Each module declares only the contracts it consumes via `<TDeps>` — and those contracts are the **interfaces you already have** in `domain/` or `contracts/` (Clean Architecture, DDD):
+
+```typescript
+// modules/auth.module.ts
+import { defineModule } from 'inwire';
+import type { IUserRepository } from '../contracts/IUserRepository';
+import type { IAuthProvider } from '../contracts/IAuthProvider';
+import { BetterAuthProvider } from '../infrastructure/BetterAuthProvider';
+import { SignInUseCase } from '../application/SignInUseCase';
+
+export const authModule = defineModule<{ IUserRepository: IUserRepository }>()((b) =>
+  b
+    .add('IAuthProvider', (): IAuthProvider => new BetterAuthProvider())
+    .add('SignInUseCase', (c) => new SignInUseCase(c.IUserRepository, c.IAuthProvider)),
+);
+```
+
+Why this is the right pattern:
+- **No shape interface to maintain.** Add a binding anywhere → `Di` grows automatically. Remove one → it shrinks.
+- **No `declare module` augmentation.** No global state, no import side-effects.
+- **Local prerequisites.** A module's `<TDeps>` is its API contract — three lines max, exactly what it needs.
+- **Cross-module references work at build time.** When `authModule` registers `SignInUseCase` that needs `IUserRepository` (provided by `persistenceModule`), the prerequisite check at `addModule()` time enforces the order.
+
+See [examples/05-zod-style-typing.ts](examples/05-zod-style-typing.ts) for a full walk-through with three modules and a derived `Di`.
+
+#### Cross-module forward references (Pinia-style)
+
+When a module needs to consume a binding **provided by another module loaded later**, the local `<TDeps>` pattern can't help — the prerequisite would have to list everything the module sees, defeating the locality. For that case, inwire exposes an augmentable global interface, exactly like Pinia's `PiniaCustomProperties` or Vue's `ComponentCustomProperties`:
+
+```typescript
+import 'inwire';
+
+declare module 'inwire' {
+  interface AppDeps {
+    IUserRepository: IUserRepository;
+    SignInUseCase: SignInUseCase;
+  }
+}
+```
+
+Each module file augments `AppDeps` with the bindings **it provides**. When you call `defineModule()` *without* a `<TDeps>` generic, `c` is typed as the global `AppDeps` — so `c.X` resolves transparently across modules, regardless of declaration order:
+
+```typescript
+// modules/auth.module.ts
+declare module 'inwire' {
+  interface AppDeps {
+    IAuthProvider: IAuthProvider;
+    SignInUseCase: SignInUseCase;
+  }
+}
+
+export const authModule = defineModule()((b) =>
+  b
+    .add('IAuthProvider', (): IAuthProvider => new BetterAuthProvider())
+    .add('SignInUseCase', (c) => new SignInUseCase(c.IUserRepository, c.IAuthProvider)),
+  //                                              ^^^^^^^^^^^^^^^^^^^^
+  //                       provided by another module — type-checked via AppDeps
+);
+```
+
+Trade-off vs `defineModule<TDeps>()`:
+
+| Pattern | You declare | Cross-module forward ref |
+|---|---|---|
+| `defineModule<TDeps>()` | what the module **consumes** (inputs) | no — must be already added |
+| `defineModule()` + `declare module` | what the module **adds** (outputs) | yes — order-independent |
+
+Both patterns coexist. Mix freely — the explicit `<TDeps>` always overrides the global mode for that module. Why two? Because not every project needs the global augmentation, and not every module needs a tight prerequisite list. Pick the one that feels lighter for the file you're writing.
+
+See [examples/06-pinia-augmentation.ts](examples/06-pinia-augmentation.ts) for a full walk-through with two modules cross-referencing each other.
+
 ### Preload
 
 ```typescript
@@ -382,6 +477,8 @@ detectDuplicateKeys(authModule, userModule);
 | [02-modular-testing.ts](examples/02-modular-testing.ts) | `npm run example:test` | Free mode, instance values, test overrides, extend + transient |
 | [03-plugin-system.ts](examples/03-plugin-system.ts) | `npm run example:plugin` | Extend chain, scoped jobs, health, JSON graph for LLM |
 | [04-modules.ts](examples/04-modules.ts) | `npm run example:modules` | addModule, module() post-build, typed reusable modules |
+| [05-zod-style-typing.ts](examples/05-zod-style-typing.ts) | `npm run example:typing` | `type AppDeps = typeof di` pattern, Clean Arch contracts, no manual interface |
+| [06-pinia-augmentation.ts](examples/06-pinia-augmentation.ts) | `npm run example:pinia` | Cross-module forward references via `declare module 'inwire'`, order-independent typing |
 
 ## Architecture
 

package/dist/index.d.mts

@@ -188,6 +188,28 @@ type Factory<T = unknown> = (container: unknown) => T;
  * Reserved method names on the container that cannot be used as dependency keys.
  */
 declare const RESERVED_KEYS: readonly ["scope", "extend", "module", "preload", "reset", "inspect", "describe", "health", "dispose", "toString"];
+/**
+ * Global, augmentable interface describing the application's dependency shape.
+ *
+ * Empty by default. Each module file augments it with the bindings IT provides,
+ * enabling **cross-module forward references** in factories — `c.X` resolves
+ * even when `X` is added by another module loaded later.
+ *
+ * @example Augment from a module file:
+ * ```typescript
+ * declare module 'inwire' {
+ *   interface AppDeps {
+ *     IUserRepository: IUserRepository;
+ *     SignInUseCase: SignInUseCase;
+ *   }
+ * }
+ * ```
+ *
+ * When `defineModule()` is called without an explicit `<TDeps>` generic, the
+ * builder's `c` parameter is typed as `AppDeps` — the union of every module's
+ * augmentations. TypeScript merges these declarations across files.
+ */
+interface AppDeps {}
 /**
  * Options for creating a scoped container.
  */
@@ -437,29 +459,49 @@ declare function container<T extends Record<string, any> = Record<string, unknow
  *
  * Use {@link defineModule} to build a `Module` with strong inference.
  */
-type Module<TDeps extends Record<string, any> = {}, TBuilt extends Record<string, any> = TDeps> = (builder: ContainerBuilder<Record<string, unknown>, TDeps>) => ContainerBuilder<Record<string, unknown>, TBuilt>;
+type Module<TDeps extends Record<string, any> = AppDeps, TBuilt extends Record<string, any> = TDeps> = (builder: ContainerBuilder<Record<string, unknown>, TDeps>) => ContainerBuilder<Record<string, unknown>, TBuilt>;
 /**
- * Defines a reusable, strongly-typed module without importing the host's deps interface.
+ * Defines a reusable, strongly-typed module.
  *
- * Pattern: `defineModule<Prerequisites>()(builder => builder.add(...))`.
- * Prerequisites are declared **locally**, not pulled from a global `AppDeps`.
- * The output type is **inferred** from the chained `.add()` calls — no manual signature.
+ * Two modes, picked by whether you pass `<TDeps>` explicitly:
  *
- * @example
+ * - **Global mode** (`defineModule()`, no generic): `c` is typed as `AppDeps`,
+ *   the augmentable global interface. Each module file augments `AppDeps` with
+ *   what it provides via `declare module 'inwire' { interface AppDeps { … } }`.
+ *   Cross-module forward references work transparently — `c.X` resolves even
+ *   when `X` is added by another module.
+ * - **Local mode** (`defineModule<TDeps>()`): `c` is typed as `TDeps`, declared
+ *   locally inline. No global augmentation needed. Use when the module's
+ *   prerequisites are a tight, fixed surface.
+ *
+ * The output type is always **inferred** from the chained `.add()` calls.
+ *
+ * @example Global mode (Pinia-style):
  * ```typescript
- * import { defineModule } from 'inwire';
+ * declare module 'inwire' {
+ *   interface AppDeps {
+ *     IUserRepository: IUserRepository;
+ *     SignInUseCase: SignInUseCase;
+ *   }
+ * }
+ *
+ * export const authModule = defineModule()((b) =>
+ *   b
+ *     .add('IUserRepository', () => new DrizzleUserRepository())
+ *     .add('SignInUseCase', (c) => new SignInUseCase(c.IUserRepository, c.IAuthProvider)),
+ *   //                                                                   ^^^^^^^^^^^^^^^
+ *   //                                          provided by another module — typed via AppDeps
+ * );
+ * ```
  *
+ * @example Local mode (explicit prerequisites):
+ * ```typescript
  * const billingModule = defineModule<{ eventBus: EventBus }>()((b) =>
  *   b.add('subscribeUseCase', (c) => new SubscribeUseCase(c.eventBus)),
  * );
- *
- * const di = container()
- *   .add('eventBus', () => new EventBus())
- *   .addModule(billingModule)
- *   .build();
  * ```
  */
-declare function defineModule<TDeps extends Record<string, any> = {}>(): <TBuilt extends Record<string, any>>(fn: (builder: ContainerBuilder<Record<string, unknown>, TDeps>) => ContainerBuilder<Record<string, unknown>, TBuilt>) => Module<TDeps, TBuilt>;
+declare function defineModule<TDeps extends Record<string, any> = AppDeps>(): <TBuilt extends Record<string, any>>(fn: (builder: ContainerBuilder<Record<string, unknown>, TDeps>) => ContainerBuilder<Record<string, unknown>, TBuilt>) => Module<TDeps, TBuilt>;
 /**
  * Extracts the prerequisite deps of a `Module`.
  */
@@ -527,5 +569,5 @@ declare function detectDuplicateKeys(...modules: Record<string, unknown>[]): str
  */
 declare function transient<T>(factory: Factory<T>): Factory<T>;
 //#endregion
-export { AsyncInitErrorWarning, CircularDependencyError, type Container, ContainerBuilder, ContainerConfigError, ContainerError, type ContainerGraph, type ContainerHealth, type ContainerWarning, type Factory, FactoryError, type IContainer, type InferModuleBuilt, type InferModuleDeps, type Module, type OnDestroy, type OnInit, type ProviderInfo, ProviderNotFoundError, ReservedKeyError, ScopeMismatchWarning, type ScopeOptions, UndefinedReturnError, container, defineModule, detectDuplicateKeys, transient };
+export { type AppDeps, AsyncInitErrorWarning, CircularDependencyError, type Container, ContainerBuilder, ContainerConfigError, ContainerError, type ContainerGraph, type ContainerHealth, type ContainerWarning, type Factory, FactoryError, type IContainer, type InferModuleBuilt, type InferModuleDeps, type Module, type OnDestroy, type OnInit, type ProviderInfo, ProviderNotFoundError, ReservedKeyError, ScopeMismatchWarning, type ScopeOptions, UndefinedReturnError, container, defineModule, detectDuplicateKeys, transient };
 //# sourceMappingURL=index.d.mts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inwire",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "Zero-ceremony dependency injection for TypeScript. Full inference, no decorators, no tokens. Built-in introspection for AI tooling.",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -30,6 +30,8 @@
     "example:test": "tsx examples/02-modular-testing.ts",
     "example:plugin": "tsx examples/03-plugin-system.ts",
     "example:modules": "tsx examples/04-modules.ts",
+    "example:typing": "tsx examples/05-zod-style-typing.ts",
+    "example:pinia": "tsx examples/06-pinia-augmentation.ts",
     "prepublishOnly": "npm run build"
   },
   "publishConfig": {