nest-hex 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 LiorVainer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,425 @@
+# nest-hex
+
+> A tiny, **class-based**, **NestJS-native** helper library for building **pluggable adapters** following the Ports & Adapters (Hexagonal Architecture) pattern with minimal boilerplate and great developer experience.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Why?
+
+Building NestJS applications with the Ports & Adapters pattern involves repetitive boilerplate:
+
+- Registering concrete implementation classes
+- Aliasing port tokens to implementations (`useExisting`)
+- Exporting only the port token (not provider objects)
+- Supporting both `register()` and `registerAsync()` patterns
+- Keeping the app responsible for configuration (no `process.env` in libraries)
+
+This library provides base classes and decorators to eliminate this boilerplate while maintaining compile-time type safety.
+
+## Features
+
+- 🎯 **Declarative**: Declare port tokens and implementations once using `@Port({ token, implementation })`
+- 🏗️ **Class-based**: Use standard NestJS dynamic modules, no function factories required
+- 🔒 **Type-safe**: `AdapterModule<TToken>` carries compile-time proof of which token it provides
+- ⚡ **Zero runtime overhead**: Uses TypeScript decorators and metadata, minimal abstraction
+- 📦 **Tiny**: Core library is under 1KB minified
+- 🧪 **Testable**: Easily mock adapters for testing
+
+## Installation
+
+```bash
+npm install nest-hex
+# or
+yarn add nest-hex
+# or
+pnpm add nest-hex
+# or
+bun add nest-hex
+```
+
+### Peer Dependencies
+
+```bash
+npm install @nestjs/common @nestjs/core reflect-metadata
+```
+
+## Quick Start
+
+### 1. Define a Port (Domain Interface)
+
+```typescript
+// storage.port.ts
+export const STORAGE_PORT = Symbol('STORAGE_PORT');
+
+export interface StoragePort {
+  upload(file: Buffer, key: string): Promise<{ url: string }>;
+  download(key: string): Promise<Buffer>;
+}
+```
+
+### 2. Create an Adapter (Infrastructure Implementation)
+
+```typescript
+// s3.adapter.ts
+import { Injectable } from '@nestjs/common';
+import { Adapter, Port } from 'nest-hex';
+import { STORAGE_PORT, type StoragePort } from './storage.port';
+
+// Implementation service
+@Injectable()
+class S3StorageService implements StoragePort {
+  async upload(file: Buffer, key: string) {
+    // AWS S3 upload logic here
+    return { url: `https://s3.amazonaws.com/bucket/${key}` };
+  }
+
+  async download(key: string) {
+    // AWS S3 download logic here
+    return Buffer.from('file contents');
+  }
+}
+
+// Adapter configuration
+interface S3Options {
+  bucket: string;
+  region: string;
+  accessKeyId?: string;
+  secretAccessKey?: string;
+}
+
+// Adapter module - single decorator declares everything!
+@Port({
+  token: STORAGE_PORT,
+  implementation: S3StorageService,
+})
+export class S3Adapter extends Adapter<S3Options> {}
+```
+
+### 3. Create a Port Module (Domain Service)
+
+```typescript
+// storage.module.ts
+import { Injectable, Module } from '@nestjs/common';
+import { InjectPort, PortModule } from 'nest-hex';
+import { STORAGE_PORT, type StoragePort } from './storage.port';
+
+// Domain service that uses the port
+@Injectable()
+export class StorageService {
+  constructor(
+    @InjectPort(STORAGE_PORT)
+    private readonly storage: StoragePort,
+  ) {}
+
+  async uploadUserAvatar(userId: string, image: Buffer) {
+    const key = `avatars/${userId}.jpg`;
+    return this.storage.upload(image, key);
+  }
+
+  async downloadUserAvatar(userId: string) {
+    const key = `avatars/${userId}.jpg`;
+    return this.storage.download(key);
+  }
+}
+
+// Port module that accepts any adapter
+@Module({})
+export class StorageModule extends PortModule<typeof StorageService> {}
+```
+
+### 4. Wire It Up in Your App
+
+```typescript
+// app.module.ts
+import { Module } from '@nestjs/common';
+import { StorageModule } from './storage/storage.module';
+import S3Adapter from './storage/adapters/s3.adapter';
+
+@Module({
+  imports: [
+    StorageModule.register({
+      adapter: S3Adapter.register({
+        bucket: 'my-app-uploads',
+        region: 'us-east-1',
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+That's it! You now have a fully type-safe, pluggable storage adapter. 🎉
+
+## Key Benefits
+
+### Before (Manual Boilerplate)
+
+```typescript
+// Lots of manual wiring...
+@Module({})
+export class S3StorageModule {
+  static register(options: S3Options): DynamicModule {
+    return {
+      module: S3StorageModule,
+      providers: [
+        S3StorageService,
+        { provide: STORAGE_PORT, useExisting: S3StorageService },
+        // More boilerplate...
+      ],
+      exports: [STORAGE_PORT],
+    };
+  }
+}
+```
+
+### After (With nest-hex)
+
+```typescript
+// Clean and declarative!
+@Port({
+  token: STORAGE_PORT,
+  implementation: S3StorageService,
+})
+export class S3Adapter extends Adapter<S3Options> {}
+```
+
+## Advanced Usage
+
+### Async Registration with Dependency Injection
+
+```typescript
+import { ConfigModule, ConfigService } from '@nestjs/config';
+
+@Module({
+  imports: [
+    StorageModule.register({
+      adapter: S3Adapter.registerAsync({
+        imports: [ConfigModule],
+        inject: [ConfigService],
+        useFactory: (config: ConfigService) => ({
+          bucket: config.get('S3_BUCKET'),
+          region: config.get('AWS_REGION'),
+          accessKeyId: config.get('AWS_ACCESS_KEY_ID'),
+          secretAccessKey: config.get('AWS_SECRET_ACCESS_KEY'),
+        }),
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Custom Imports and Extra Ports
+
+```typescript
+@Port({
+  token: HTTP_CLIENT_PORT,
+  implementation: AxiosHttpClient,
+})
+class AxiosAdapterClass extends Adapter<AxiosOptions> {
+  protected override imports(options: AxiosOptions) {
+    return [
+      HttpModule.register({
+        baseURL: options.baseUrl,
+        timeout: options.timeout,
+      }),
+    ];
+  }
+
+  protected override extraPoviders(options: AxiosOptions) {
+    return [
+      {
+        provide: 'HTTP_CLIENT_CONFIG',
+        useValue: options,
+      },
+    ];
+  }
+}
+```
+
+### Swapping Adapters
+
+The beauty of the Ports & Adapters pattern is that you can easily swap implementations:
+
+```typescript
+// Development: Use filesystem storage
+import FilesystemAdapter from './storage/adapters/filesystem.adapter';
+
+// Production: Use AWS S3
+import S3Adapter from './storage/adapters/s3.adapter';
+
+const adapter = process.env.NODE_ENV === 'production'
+  ? S3Adapter.register({ bucket: 'prod-bucket', region: 'us-east-1' })
+  : FilesystemAdapter.register({ basePath: './uploads' });
+
+@Module({
+  imports: [
+    StorageModule.register({ adapter }),
+  ],
+})
+export class AppModule {}
+```
+
+### Testing with Mock Adapters
+
+```typescript
+import { Adapter, Port } from 'nest-hex';
+
+class MockStorageService {
+  async upload(file: Buffer, key: string) {
+    return { url: `mock://storage/${key}` };
+  }
+
+  async download(key: string) {
+    return Buffer.from('mock file contents');
+  }
+}
+
+@Port({
+  token: STORAGE_PORT,
+  implementation: MockStorageService,
+})
+export class MockStorageAdapter extends Adapter<void> {}
+
+// Use in tests
+const module = await Test.createTestingModule({
+  imports: [
+    StorageModule.register({
+      adapter: MockStorageAdapter.register(undefined),
+    }),
+  ],
+}).compile();
+```
+
+## API Reference
+
+### Core Classes
+
+#### `Adapter<TOptions>`
+
+Abstract base class for building adapter modules.
+
+**Methods:**
+- `static register<TToken, TOptions>(options: TOptions): AdapterModule<TToken>` - Synchronous registration
+- `static registerAsync<TToken, TOptions>(config: AsyncConfig): AdapterModule<TToken>` - Async registration with DI
+
+**Protected Hooks:**
+- `protected imports(options?: TOptions): unknown[]` - Override to import other NestJS modules
+- `protected extraPoviders(options: TOptions): Port[]` - Override to add additional providers
+
+#### `PortModule<TService>`
+
+Abstract base class for building port modules that consume adapters.
+
+**Methods:**
+- `static register<TToken>({ adapter }: { adapter?: AdapterModule<TToken> }): DynamicModule`
+
+### Decorators
+
+#### `@Port({ token, implementation })`
+
+Class decorator that declares which port token an adapter provides and its implementation class.
+
+**Parameters:**
+- `token: TToken` - The port token (usually a Symbol)
+- `implementation: Type<unknown>` - The concrete implementation class
+
+**Example:**
+```typescript
+@Port({
+  token: STORAGE_PORT,
+  implementation: S3StorageService,
+})
+class S3Adapter extends Adapter<S3Options> {}
+```
+
+#### `@InjectPort(token)`
+
+Parameter decorator for injecting a port token into service constructors.
+
+**Example:**
+```typescript
+constructor(
+  @InjectPort(STORAGE_PORT)
+  private readonly storage: StoragePort,
+) {}
+```
+
+### Types
+
+#### `AdapterModule<TToken>`
+
+A DynamicModule that carries compile-time proof it provides `TToken`.
+
+```typescript
+type AdapterModule<TToken> = DynamicModule & {
+  __provides: TToken;
+};
+```
+
+## Best Practices
+
+### ✅ Do's
+
+- **Export port tokens, not provider objects**
+  ```typescript
+  exports: [STORAGE_PORT]  // ✅ Correct
+  ```
+
+- **Keep configuration in the app layer**
+  ```typescript
+  // ✅ Good: App provides config
+  S3Adapter.register({
+    bucket: process.env.S3_BUCKET,
+  })
+  ```
+
+- **Use `@InjectPort` for clarity**
+  ```typescript
+  @InjectPort(STORAGE_PORT)  // ✅ Clear intent
+  ```
+
+- **Create small, focused adapters**
+  - One adapter = one infrastructure concern
+
+### ❌ Don'ts
+
+- **Don't export provider objects**
+  ```typescript
+  exports: [{ provide: STORAGE_PORT, useExisting: S3Service }]  // ❌ Wrong
+  ```
+
+- **Don't use `process.env` in adapters**
+  ```typescript
+  // ❌ Bad: Config hard-coded in adapter
+  class S3Adapter {
+    bucket = process.env.S3_BUCKET;
+  }
+  ```
+
+- **Don't mix domain logic with adapters**
+  - Adapters = infrastructure only
+  - Domain logic = port modules/services
+
+## Examples
+
+See the [`examples/`](./examples) directory for complete working examples:
+
+- **Object Storage** - S3 adapter with file upload/download
+- **Currency Rates** - HTTP API adapter with rate conversion
+- **Basic Examples** - Decorator usage patterns
+
+## Documentation
+
+- 📖 [Full Specification](./spec/spec.md) - Complete implementation guide with AWS S3 and HTTP API examples
+- 🔧 [API Reference](#api-reference) - Detailed API documentation
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for contribution guidelines.

package/dist/index.d.ts

@@ -0,0 +1,164 @@
+import { Provider } from "@nestjs/common";
+import { DynamicModule } from "@nestjs/common";
+/**
+* A DynamicModule that carries a compile-time proof it provides `TToken`.
+*
+* The `__provides` field is used only for TypeScript structural typing to ensure
+* that feature modules receive adapters that provide the correct token type.
+* This enables compile-time type safety without runtime overhead.
+*
+* @template TToken - The token type that this adapter module provides
+*
+* @example
+* ```typescript
+* const s3Module: AdapterModule<typeof STORAGE_TOKEN> = S3Adapter.register(options);
+* // TypeScript ensures s3Module provides STORAGE_TOKEN
+* ```
+*/
+type AdapterModule<TToken> = DynamicModule & {
+	__provides: TToken;
+};
+type PortConfig<
+	Token,
+	Port
+> = {
+	token: Token;
+	port: Port;
+};
+/**
+* Abstract base class for building NestJS adapter modules following the Ports & Adapters pattern.
+*
+* Adapters are dynamic modules that provide a port token and hide infrastructure details.
+* This base class automatically handles provider registration, token aliasing, and exports
+* by reading metadata from the @Port decorator.
+*
+* @template TOptions - The options type for configuring this adapter
+*
+* @example
+* ```typescript
+* @Port({
+*   token: STORAGE_PORT,
+*   implementation: S3Service
+* })
+* class S3Adapter extends Adapter<S3Options> {
+*   protected override imports(options: S3Options) {
+*     return []; // Optional: import other modules
+*   }
+*
+*   protected override extraPoviders(options: S3Options) {
+*     return []; // Optional: additional providers
+*   }
+* }
+* ```
+*/
+declare class Adapter<TOptions> {
+	/**
+	* Optional hook to import other NestJS modules.
+	* Override this method to add module dependencies.
+	*
+	* @param _options - The adapter configuration options
+	* @returns Array of modules to import
+	*/
+	protected imports(_options?: TOptions): unknown[];
+	/**
+	* Optional hook to provide additional providers.
+	* Override this method to add helper services, factories, or initialization logic.
+	*
+	* @param _options - The adapter configuration options
+	* @returns Array of additional providers
+	*/
+	protected extraPoviders(_options: TOptions): Provider[];
+	/**
+	* Synchronous registration method.
+	* Creates a dynamic module with the adapter's port token and implementation.
+	*
+	* @param options - The adapter configuration options
+	* @returns An AdapterModule with compile-time token proof
+	* @throws Error if @Port decorator is missing or incomplete
+	*/
+	static register<
+		TToken,
+		TOptions
+	>(this: new () => Adapter<TOptions>, options: TOptions): AdapterModule<TToken>;
+	/**
+	* Asynchronous registration method with dependency injection support.
+	* Creates a dynamic module where options are resolved via DI.
+	*
+	* @param options - Async configuration with factory, imports, and inject
+	* @returns An AdapterModule with compile-time token proof
+	* @throws Error if @Port decorator is missing or incomplete
+	*
+	* @example
+	* ```typescript
+	* S3Adapter.registerAsync({
+	*   imports: [ConfigModule],
+	*   inject: [ConfigService],
+	*   useFactory: (config) => config.get('s3'),
+	* })
+	* ```
+	*/
+	static registerAsync<
+		TToken,
+		TOptions
+	>(this: new () => Adapter<TOptions>, options: {
+		imports?: unknown[];
+		inject?: unknown[];
+		useFactory: (...args: unknown[]) => TOptions | Promise<TOptions>;
+	}): AdapterModule<TToken>;
+}
+import { Type } from "@nestjs/common";
+/**
+* Declares the port configuration for an adapter (token and implementation).
+*
+* This decorator stores both the port token and implementation class in metadata,
+* which is read at runtime by the Adapter base class's register() and registerAsync() methods.
+*
+* @param config - Port configuration object
+* @param config.token - The port token this adapter provides
+* @param config.implementation - The concrete implementation class that provides the port functionality
+*
+* @example
+* ```typescript
+* @Port({
+*   token: OBJECT_STORAGE_PORT,
+*   implementation: S3ObjectStorageService
+* })
+* class S3Adapter extends Adapter<S3Options> {}
+* ```
+*/
+declare function Port2<C extends PortConfig<any, any>>(config: {
+	token: C["token"];
+	implementation: Type<C["port"]>;
+}): ClassDecorator;
+/**
+* DX decorator for injecting a port token into service constructors.
+* This is a shorthand for @Inject(token) that provides clearer semantics.
+*
+* @param token - The port token to inject
+*
+* @example
+* ```typescript
+* @Injectable()
+* class ObjectStorageService {
+*   constructor(
+*     @InjectPort(OBJECT_STORAGE_PROVIDER)
+*     private readonly storage: ObjectStoragePort,
+*   ) {}
+* }
+* ```
+*/
+declare function InjectPort<TToken>(token: TToken): ParameterDecorator;
+import { DynamicModule as DynamicModule2 } from "@nestjs/common";
+declare class PortModule<_TService> {
+	/**
+	* Registers the port module with an adapter.
+	*
+	* @param config - Configuration object containing the adapter module
+	* @param config.adapter - An adapter module that provides the required port
+	* @returns A dynamic module that imports the adapter and provides the service
+	*/
+	static register<TToken>({ adapter }: {
+		adapter?: AdapterModule<TToken>;
+	}): DynamicModule2;
+}
+export { PortModule, PortConfig, Port2 as Port, InjectPort, AdapterModule, Adapter };

package/dist/index.js

@@ -0,0 +1,137 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  PortModule: () => PortModule,
+  Port: () => Port,
+  InjectPort: () => InjectPort,
+  Adapter: () => Adapter
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/core/adapter.base.ts
+var import_reflect_metadata = require("reflect-metadata");
+
+// src/core/constants.ts
+var PORT_TOKEN_METADATA = Symbol("PORT_TOKEN_METADATA");
+var PORT_IMPLEMENTATION_METADATA = Symbol("PORT_IMPLEMENTATION_METADATA");
+
+// src/core/adapter.base.ts
+class Adapter {
+  imports(_options) {
+    return [];
+  }
+  extraPoviders(_options) {
+    return [];
+  }
+  static register(options) {
+    const instance = new this;
+    const token = Reflect.getMetadata(PORT_TOKEN_METADATA, this);
+    const implementation = Reflect.getMetadata(PORT_IMPLEMENTATION_METADATA, this);
+    if (!token) {
+      throw new Error(`${this.name} must be decorated with @Port() and specify 'token'`);
+    }
+    if (!implementation) {
+      throw new Error(`${this.name} must be decorated with @Port() and specify 'implementation'`);
+    }
+    return {
+      module: this,
+      imports: instance.imports(options),
+      providers: [
+        implementation,
+        { provide: token, useExisting: implementation },
+        ...instance.extraPoviders(options)
+      ],
+      exports: [token],
+      __provides: token
+    };
+  }
+  static registerAsync(options) {
+    const instance = new this;
+    const token = Reflect.getMetadata(PORT_TOKEN_METADATA, this);
+    const implementation = Reflect.getMetadata(PORT_IMPLEMENTATION_METADATA, this);
+    if (!token) {
+      throw new Error(`${this.name} must be decorated with @Port() and specify 'token'`);
+    }
+    if (!implementation) {
+      throw new Error(`${this.name} must be decorated with @Port() and specify 'implementation'`);
+    }
+    return {
+      module: this,
+      imports: [...options.imports ?? [], ...instance.imports()],
+      providers: [
+        implementation,
+        { provide: token, useExisting: implementation },
+        ...instance.extraPoviders({})
+      ],
+      exports: [token],
+      __provides: token
+    };
+  }
+}
+// src/core/decorators.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+var import_common = require("@nestjs/common");
+function Port(config) {
+  return (target) => {
+    Reflect.defineMetadata(PORT_TOKEN_METADATA, config.token, target);
+    Reflect.defineMetadata(PORT_IMPLEMENTATION_METADATA, config.implementation, target);
+  };
+}
+function InjectPort(token) {
+  return import_common.Inject(token);
+}
+// src/core/port-module.base.ts
+var import_reflect_metadata3 = require("reflect-metadata");
+var import_common2 = require("@nestjs/common");
+class PortModule {
+  static register({
+    adapter
+  }) {
+    return {
+      module: PortModule,
+      imports: adapter ? [adapter] : []
+    };
+  }
+}
+PortModule = __legacyDecorateClassTS([
+  import_common2.Module({})
+], PortModule);

package/package.json

@@ -0,0 +1,88 @@
+{
+	"name": "nest-hex",
+	"version": "0.2.0",
+	"description": "A tiny NestJS-native library for building pluggable adapters (Ports & Adapters / Hexagonal) using class-based Dynamic Modules, with great DX and strong type safety.",
+	"homepage": "https://github.com/LiorVainer/nest-hex#readme",
+	"bugs": {
+		"url": "https://github.com/LiorVainer/nest-hex/issues"
+	},
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"files": [
+		"dist"
+	],
+	"bin": {
+		"nest-hex": "./dist/cli/bin.js"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/LiorVainer/nest-hex.git"
+	},
+	"scripts": {
+		"build": "bunup",
+		"dev": "bunup --watch",
+		"prepare": "bun simple-git-hooks",
+		"cli": "bun run src/cli/bin.ts",
+		"cli:init": "bun run src/cli/bin.ts init",
+		"cli:generate": "bun run src/cli/bin.ts generate",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write .",
+		"release": "bumpp --commit --push --tag",
+		"test": "bun test",
+		"test:coverage": "bun test --coverage",
+		"test:watch": "bun test --watch",
+		"type-check": "tsc --noEmit",
+		"type-check:examples": "tsc --noEmit --project examples/tsconfig.json",
+		"vibecheck": "npx vibechck ."
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.3.10",
+		"@inkjs/ui": "^2.0.0",
+		"@nestjs/common": "^11.0.0",
+		"@nestjs/testing": "^11.1.11",
+		"@types/bun": "^1.3.5",
+		"@types/react": "^18.3.12",
+		"bumpp": "^10.3.2",
+		"bunup": "^0.16.11",
+		"commander": "^12.0.0",
+		"handlebars": "^4.7.8",
+		"ink": "^5.0.1",
+		"react": "^18.3.1",
+		"reflect-metadata": "^0.2.0",
+		"simple-git-hooks": "^2.13.1",
+		"typescript": "^5.9.3"
+	},
+	"peerDependencies": {
+		"@nestjs/common": ">=10.0.0",
+		"reflect-metadata": ">=0.1.13",
+		"typescript": ">=4.5.0"
+	},
+	"peerDependenciesMeta": {
+		"typescript": {
+			"optional": true
+		}
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"require": "./dist/index.js",
+			"import": "./dist/index.js"
+		},
+		"./cli": {
+			"types": "./dist/cli/index.d.ts",
+			"require": "./dist/cli/index.js",
+			"import": "./dist/cli/index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"simple-git-hooks": {
+		"pre-commit": "bun run lint:fix && bun run type-check"
+	},
+	"dependencies": {
+		"ts-deepmerge": "^7.0.3"
+	}
+}