npm package: @rafikidota/iroh-schematics
Description: Sometimes, the best way to solve your own problems is to help someone else.
Author: rafiki
Latest version: 0.1.1

# Iroh Schematics

NestJS schematics for generating CRUD modules with Domain-Driven Design patterns.

## Overview

Iroh schematics provide a set of tools to quickly generate NestJS CRUD modules following best practices and DDD patterns. The schematics generate all necessary files including controllers, services, repositories, domain models, and DTOs.

## Prerequisites

Before using the schematics, ensure you have the following:
- A NestJS project set up
- Node.js and npm/pnpm installed
- Basic understanding of NestJS and TypeORM

## Installation

Install the schematics globally or use npx:

```bash
# Global installation
npm install -g @rafikidota/iroh-schematics

# Or use npx (no installation required)
npx @rafikidota/iroh-schematics
```

## Available Schematics

### 1. Init Schematic

Generates the base modules (`core` and `common`) for your application:

```bash
npx nest g -c @rafikidota/iroh-schematics init
```

This creates:
- `common/common.module.ts` - Common configuration and utilities
- `modules/core.module.ts` - Core application module

### 2. CRUD Schematic

Generates a complete CRUD module for an entity:

```bash
npx nest g -c @rafikidota/iroh-schematics crud <module-name>
```

Example:
```bash
npx nest g -c @rafikidota/iroh-schematics crud user
```

This generates:
- Controller with CRUD endpoints
- Service with business logic
- Repository for data access
- Domain model and interface
- Persistence entity
- DTOs (Create, Update, View, FindOne, FindMany)
- Mapper between layers
- Unit tests

### 3. Use-Case Schematic

Generates a specific use case:

```bash
npx nest g -c @rafikidota/iroh-schematics use-case <use-case-name>
```

## Generated Module Structure

When you run the CRUD schematic, it creates the following structure:

```
src/modules/<module-name>/
├── app/
│   └── dto/
│       ├── <module-name>.create.dto.ts
│       ├── <module-name>.update.dto.ts
│       ├── <module-name>.view.ts
│       ├── <module-name>.find-one.dto.ts
│       └── <module-name>.find-many.dto.ts
├── domain/
│   ├── <module-name>.domain.ts
│   └── <module-name>.interface.ts
├── infra/
│   ├── <module-name>.persistence.ts
│   ├── <module-name>.mapper.ts
│   └── <module-name>.repository.ts
├── test/
│   ├── <module-name>.controller.spec.ts
│   ├── <module-name>.service.spec.ts
│   └── provider/
│       └── <module-name>.typeorm.repository.ts
├── <module-name>.controller.ts
├── <module-name>.service.ts
├── <module-name>.module.ts
└── index.ts
```

## Usage Example

When you generate a CRUD module, the schematic automatically imports it in your `core.module.ts` located at `src/modules/`. 

For example, after running:
```bash
npx nest g -c @rafikidota/iroh-schematics crud user
```

The schematic will automatically update your `CoreModule`:

```typescript
import { Module } from '@nestjs/common';
import { UserModule } from '../user/user.module';  // Auto-imported
// Other modules...

@Module({
  imports: [
    UserModule,  // Auto-added
    // Other modules...
  ],
})
export class CoreModule {}
```

**Note:** The automatic import happens only if the CoreModule exists at the expected location (`src/modules/core.module.ts`).

## Development

To build the schematics:

```bash
# Install dependencies
pnpm install

# Build the project
pnpm build

# Run tests
pnpm test
```

## Additional Resources

- [NestJS Documentation](https://docs.nestjs.com/)
- [TypeORM Documentation](https://typeorm.io/)
- [Angular Schematics Documentation](https://angular.io/guide/schematics)

## License

MIT