create-easy-stack 1.0.3

package/lib/scaffold.mjs

@@ -0,0 +1,157 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import {
+  appendLines,
+  copyTemplateDir,
+  injectAtMarker,
+  mergePackageJson,
+  readJson,
+  writeJson,
+} from './fs-utils.mjs';
+import { resolveInfra } from './registry.mjs';
+
+export const LOCK_FILE = '.my-stack.json';
+
+const COMPOSE_SKELETON = `services:
+  # @infra:services
+
+volumes:
+  # @infra:volumes
+`;
+
+/** Names usable inside templates: {{PROJECT_NAME}}, {{PROJECT_NAME_PASCAL}}, {{PROJECT_NAME_SNAKE}}. */
+export function buildVars(projectName) {
+  const words = projectName.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+  const lower = words.map((word) => word.toLowerCase());
+  return {
+    PROJECT_NAME: projectName,
+    PROJECT_NAME_PASCAL: lower.map((w) => w[0].toUpperCase() + w.slice(1)).join(''),
+    PROJECT_NAME_SNAKE: lower.join('_'),
+  };
+}
+
+export function isValidProjectName(name) {
+  return /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(name);
+}
+
+function run(command, args, cwd) {
+  const result = spawnSync(command, args, {
+    cwd,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+  return result.status === 0;
+}
+
+/** Applies one infra module (files, deps, env, docker service, injections) onto a project. */
+function applyInfra(projectDir, infra, vars, log) {
+  const filesDir = path.join(infra.dir, 'files');
+  if (fs.existsSync(filesDir)) {
+    const { skipped } = copyTemplateDir(filesDir, projectDir, vars, { overwrite: false });
+    for (const file of skipped) log(`  skipped existing file: ${file}`);
+  }
+
+  mergePackageJson(projectDir, infra);
+
+  if (infra.env?.length) {
+    appendLines(path.join(projectDir, '.env.example'), ['', ...infra.env]);
+  }
+
+  if (infra.docker) {
+    const composeFile = path.join(projectDir, 'docker-compose.yml');
+    if (!fs.existsSync(composeFile)) fs.writeFileSync(composeFile, COMPOSE_SKELETON);
+    const service = fs
+      .readFileSync(path.join(infra.dir, infra.docker.file), 'utf8')
+      .replace(/\{\{([A-Z_]+)\}\}/g, (m, key) => vars[key] ?? m)
+      .trimEnd()
+      .split(/\r?\n/);
+    injectAtMarker(composeFile, '# @infra:services', [...service, '']);
+    const volumes = (infra.docker.volumes ?? []).map((name) => `${name}:`);
+    if (volumes.length) injectAtMarker(composeFile, '# @infra:volumes', volumes);
+  }
+
+  for (const step of infra.inject ?? []) {
+    const file = path.join(projectDir, step.file);
+    if (!injectAtMarker(file, step.marker, step.lines)) {
+      log(`  ! marker "${step.marker}" not found in ${step.file} (add it by hand)`);
+    }
+  }
+}
+
+/**
+ * Creates `projectDir` from `template`, then layers the requested infra on top.
+ * Returns what happened so the CLI can print an accurate summary.
+ */
+export function createProject({ template, infra: requested = [], projectDir, availableInfra, log = () => {} }) {
+  const projectName = path.basename(projectDir);
+  const vars = buildVars(projectName);
+  const { ordered, added } = resolveInfra(requested, availableInfra);
+
+  const unsupported = ordered.filter(
+    (infra) => infra.templates && !infra.templates.includes(template.id),
+  );
+  if (unsupported.length) {
+    throw new Error(
+      `Infra not available for ${template.id}: ${unsupported.map((i) => i.id).join(', ')}`,
+    );
+  }
+
+  fs.mkdirSync(projectDir, { recursive: true });
+  copyTemplateDir(path.join(template.dir, 'files'), projectDir, vars);
+
+  for (const infra of ordered) {
+    log(`+ infra: ${infra.id}`);
+    applyInfra(projectDir, infra, vars, log);
+  }
+
+  if (fs.existsSync(path.join(projectDir, '.env.example'))) {
+    const envFile = path.join(projectDir, '.env');
+    if (!fs.existsSync(envFile)) {
+      fs.copyFileSync(path.join(projectDir, '.env.example'), envFile);
+    }
+  }
+
+  writeJson(path.join(projectDir, LOCK_FILE), {
+    template: template.id,
+    infra: ordered.map((infra) => infra.id),
+  });
+
+  return { projectName, vars, infra: ordered, autoAdded: added };
+}
+
+/** `create-my-stack add <infra>` — layers more infra onto a project created earlier. */
+export function addInfraToProject({ projectDir, infra: requested, availableInfra, log = () => {} }) {
+  const lockPath = path.join(projectDir, LOCK_FILE);
+  if (!fs.existsSync(lockPath)) {
+    throw new Error(`${LOCK_FILE} not found in ${projectDir}; was it created by create-my-stack?`);
+  }
+  const lock = readJson(lockPath);
+  const installed = new Set(lock.infra ?? []);
+  const vars = buildVars(path.basename(projectDir));
+
+  const { ordered, added } = resolveInfra(requested, availableInfra);
+  const pending = ordered.filter((infra) => !installed.has(infra.id));
+  for (const infra of pending) {
+    if (infra.templates && !infra.templates.includes(lock.template)) {
+      throw new Error(`Infra "${infra.id}" does not support template ${lock.template}`);
+    }
+  }
+
+  for (const infra of pending) {
+    log(`+ infra: ${infra.id}`);
+    applyInfra(projectDir, infra, vars, log);
+  }
+
+  writeJson(lockPath, { ...lock, infra: [...installed, ...pending.map((infra) => infra.id)] });
+  return { added: pending, autoAdded: added.filter((a) => !installed.has(a.id)) };
+}
+
+export function initGit(projectDir) {
+  if (run('git', ['--version'], projectDir) === false) return false;
+  return run('git', ['init', '-q'], projectDir);
+}
+
+export function installDependencies(projectDir, packageManager) {
+  return run(packageManager, ['install'], projectDir);
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "create-easy-stack",
+  "version": "1.0.3",
+  "description": "Personal project generator: NestJS DDD, React/Vue FSD & monolith templates + pluggable infra (Prisma, Redis, RabbitMQ...).",
+  "type": "module",
+  "bin": {
+    "create-easy-stack": "./bin/create.mjs"
+  },
+  "scripts": {
+    "create": "node bin/create.mjs",
+    "list": "node bin/create.mjs list",
+    "test": "echo \"No tests specified\" && exit 0",
+    "smoke": "node scripts/smoke.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "prompts": "^2.4.2"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "infra/"
+  ],
+  "author": "Thuy Phuoc Thinh <thuyphuocthinh@npm>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thuyphuocthinh/create-easy-stack.git"
+  },
+  "homepage": "https://github.com/thuyphuocthinh/create-easy-stack#readme",
+  "bugs": {
+    "url": "https://github.com/thuyphuocthinh/create-easy-stack/issues"
+  }
+}

package/templates/nest-ddd/files/.env.example

@@ -0,0 +1,5 @@
+NODE_ENV=development
+PORT=3000
+# Comma separated list; '*' is allowed in development only
+CORS_ORIGINS=
+APP_NAME="{{PROJECT_NAME}}"

package/templates/nest-ddd/files/.husky/commit-msg

@@ -0,0 +1 @@
+npx --no-install commitlint --edit "$1"

package/templates/nest-ddd/files/.husky/pre-commit

@@ -0,0 +1 @@
+npx lint-staged

package/templates/nest-ddd/files/.oxlintrc.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "rules": {
+    "typescript/no-explicit-any": "off",
+    "typescript/no-floating-promises": "error"
+  },
+  "env": {
+    "node": true
+  }
+}

package/templates/nest-ddd/files/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all"
+}

package/templates/nest-ddd/files/_gitignore

@@ -0,0 +1,40 @@
+# compiled output
+/dist
+/node_modules
+*.tsbuildinfo
+
+# Logs
+logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# OS
+.DS_Store
+
+# Tests
+/coverage
+/.nyc_output
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+# dotenv
+.env
+.env.test
+.env.production
+
+/generated/prisma

package/templates/nest-ddd/files/commitlint.config.js

@@ -0,0 +1,3 @@
+export default {
+  extends: ['@commitlint/config-conventional'],
+};

package/templates/nest-ddd/files/nest-cli.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true
+  }
+}

package/templates/nest-ddd/files/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.0.1",
+  "description": "",
+  "private": true,
+  "license": "UNLICENSED",
+  "type": "module",
+  "scripts": {
+    "build": "nest build",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "oxlint --type-aware src/ test/",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:cov": "vitest run --coverage",
+    "test:e2e": "vitest run --config ./vitest.config.e2e.ts",
+    "gen": "plop",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@nestjs/common": "^12.0.1",
+    "@nestjs/config": "^12.0.0",
+    "@nestjs/core": "^12.0.1",
+    "@nestjs/cqrs": "^12.0.0",
+    "@nestjs/platform-express": "^12.0.1",
+    "@nestjs/swagger": "^12.0.1",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.15.1",
+    "express": "^5.2.1",
+    "helmet": "^8.3.0",
+    "nestjs-cls": "^6.3.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^21.2.2",
+    "@commitlint/config-conventional": "^21.2.2",
+    "@nestjs/cli": "^12.0.0",
+    "@nestjs/schematics": "^12.0.0",
+    "@nestjs/testing": "^12.0.1",
+    "@types/express": "^5.0.0",
+    "@types/node": "^24.0.0",
+    "@types/supertest": "^7.0.0",
+    "@vitest/coverage-v8": "^4.1.2",
+    "dotenv": "^18.0.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.5.1",
+    "oxlint": "^1.58.0",
+    "oxlint-tsgolint": "^7.0.2001",
+    "plop": "^4.0.5",
+    "prettier": "^3.4.2",
+    "source-map-support": "^0.5.21",
+    "supertest": "^7.0.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "oxlint --fix",
+      "prettier --write"
+    ]
+  }
+}

package/templates/nest-ddd/files/plop-templates/command/command.ts.hbs

@@ -0,0 +1,5 @@
+import { ICommand } from '@nestjs/cqrs';
+
+export class {{Pascal}}Command implements ICommand {
+  constructor(public readonly id: string) {}
+}

package/templates/nest-ddd/files/plop-templates/command/handler.ts.hbs

@@ -0,0 +1,30 @@
+import { CommandHandler, ICommandHandler } from '@nestjs/cqrs';
+import { Inject, Logger } from '@nestjs/common';
+import { {{Pascal}}Command } from './{{kebab}}.command.js';
+import { {{ModulePascal}}DomainException } from '../../domain/index.js';
+import type { I{{ModulePascal}}Repository } from '../../domain/index.js';
+import { {{ModulePascal}}ErrorCodes } from '@/core/index.js';
+
+@CommandHandler({{Pascal}}Command)
+export class {{Pascal}}Handler implements ICommandHandler<{{Pascal}}Command> {
+  private readonly logger = new Logger({{Pascal}}Handler.name);
+
+  constructor(
+    @Inject('I{{ModulePascal}}Repository')
+    private readonly repo: I{{ModulePascal}}Repository,
+  ) {}
+
+  async execute(command: {{Pascal}}Command): Promise<void> {
+    this.logger.log(`Executing {{Pascal}}Command for ${command.id}`);
+
+    const entity = await this.repo.findById(command.id);
+    if (!entity) {
+      throw new {{ModulePascal}}DomainException(
+        {{ModulePascal}}ErrorCodes.{{ModuleConstant}}_NOT_FOUND,
+      );
+    }
+
+    // TODO: call a domain method on `entity` (business rules live there), then:
+    await this.repo.save(entity);
+  }
+}

package/templates/nest-ddd/files/plop-templates/module/application/commands/create-{{kebab}}.command.ts.hbs

@@ -0,0 +1,5 @@
+import { ICommand } from '@nestjs/cqrs';
+
+export class Create{{Pascal}}Command implements ICommand {
+  constructor(public readonly name: string) {}
+}

package/templates/nest-ddd/files/plop-templates/module/application/commands/create-{{kebab}}.handler.spec.ts.hbs

@@ -0,0 +1,35 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { Create{{Pascal}}Handler } from './create-{{kebab}}.handler.js';
+import { Create{{Pascal}}Command } from './create-{{kebab}}.command.js';
+import { {{Pascal}}, {{Pascal}}DomainException } from '../../domain/index.js';
+import { {{Pascal}}ErrorCodes } from '@/core/index.js';
+
+describe('Create{{Pascal}}Handler', () => {
+  let handler: Create{{Pascal}}Handler;
+  let {{camel}}Repo: any;
+
+  beforeEach(() => {
+    {{camel}}Repo = { findById: vi.fn(), save: vi.fn() };
+    handler = new Create{{Pascal}}Handler({{camel}}Repo);
+  });
+
+  it('creates and saves a {{kebab}}', async () => {
+    {{camel}}Repo.save.mockResolvedValueOnce(undefined);
+
+    const {{camel}} = await handler.execute(new Create{{Pascal}}Command('Sample'));
+
+    expect({{camel}}).toBeInstanceOf({{Pascal}});
+    expect({{camel}}.name).toBe('Sample');
+    expect({{camel}}Repo.save).toHaveBeenCalledWith({{camel}});
+  });
+
+  it('rejects an empty name', async () => {
+    await expect(handler.execute(new Create{{Pascal}}Command('  '))).rejects.toThrow(
+      {{Pascal}}DomainException,
+    );
+    await expect(handler.execute(new Create{{Pascal}}Command('  '))).rejects.toMatchObject({
+      code: {{Pascal}}ErrorCodes.{{CONSTANT}}_INVALID_NAME.code,
+    });
+    expect({{camel}}Repo.save).not.toHaveBeenCalled();
+  });
+});

package/templates/nest-ddd/files/plop-templates/module/application/commands/create-{{kebab}}.handler.ts.hbs

@@ -0,0 +1,25 @@
+import { CommandHandler, ICommandHandler } from '@nestjs/cqrs';
+import { Inject, Logger } from '@nestjs/common';
+import { Create{{Pascal}}Command } from './create-{{kebab}}.command.js';
+import { {{Pascal}} } from '../../domain/index.js';
+import type { I{{Pascal}}Repository } from '../../domain/index.js';
+
+@CommandHandler(Create{{Pascal}}Command)
+export class Create{{Pascal}}Handler implements ICommandHandler<Create{{Pascal}}Command> {
+  private readonly logger = new Logger(Create{{Pascal}}Handler.name);
+
+  constructor(
+    @Inject('I{{Pascal}}Repository')
+    private readonly {{camel}}Repo: I{{Pascal}}Repository,
+  ) {}
+
+  async execute(command: Create{{Pascal}}Command): Promise<{{Pascal}}> {
+    this.logger.log(`Executing Create{{Pascal}}Command: ${command.name}`);
+
+    const {{camel}} = {{Pascal}}.create(command.name);
+    await this.{{camel}}Repo.save({{camel}});
+
+    this.logger.log(`Created {{kebab}} with ID: ${ {{camel}}.id }`);
+    return {{camel}};
+  }
+}

package/templates/nest-ddd/files/plop-templates/module/application/index.ts.hbs

@@ -0,0 +1,5 @@
+export * from './commands/create-{{kebab}}.command.js';
+export * from './commands/create-{{kebab}}.handler.js';
+export * from './queries/get-{{kebab}}-by-id.query.js';
+export * from './queries/get-{{kebab}}-by-id.handler.js';
+// @plop:exports

package/templates/nest-ddd/files/plop-templates/module/application/queries/get-{{kebab}}-by-id.handler.ts.hbs

@@ -0,0 +1,29 @@
+import { IQueryHandler, QueryHandler } from '@nestjs/cqrs';
+import { Inject, Logger } from '@nestjs/common';
+import { Get{{Pascal}}ByIdQuery } from './get-{{kebab}}-by-id.query.js';
+import { {{Pascal}}, {{Pascal}}DomainException } from '../../domain/index.js';
+import type { I{{Pascal}}Repository } from '../../domain/index.js';
+import { {{Pascal}}ErrorCodes } from '@/core/index.js';
+
+@QueryHandler(Get{{Pascal}}ByIdQuery)
+export class Get{{Pascal}}ByIdHandler implements IQueryHandler<Get{{Pascal}}ByIdQuery> {
+  private readonly logger = new Logger(Get{{Pascal}}ByIdHandler.name);
+
+  constructor(
+    @Inject('I{{Pascal}}Repository')
+    private readonly {{camel}}Repo: I{{Pascal}}Repository,
+  ) {}
+
+  async execute(query: Get{{Pascal}}ByIdQuery): Promise<{{Pascal}}> {
+    this.logger.debug(`Executing Get{{Pascal}}ByIdQuery: ${query.id}`);
+
+    const {{camel}} = await this.{{camel}}Repo.findById(query.id);
+    if (!{{camel}}) {
+      throw new {{Pascal}}DomainException(
+        {{Pascal}}ErrorCodes.{{CONSTANT}}_NOT_FOUND,
+        `{{Pascal}} with ID ${query.id} not found`,
+      );
+    }
+    return {{camel}};
+  }
+}

package/templates/nest-ddd/files/plop-templates/module/application/queries/get-{{kebab}}-by-id.query.ts.hbs

@@ -0,0 +1,5 @@
+import { IQuery } from '@nestjs/cqrs';
+
+export class Get{{Pascal}}ByIdQuery implements IQuery {
+  constructor(public readonly id: string) {}
+}

package/templates/nest-ddd/files/plop-templates/module/domain/entities/{{kebab}}.entity.ts.hbs

@@ -0,0 +1,37 @@
+import { AggregateRoot } from '@/core/index.js';
+import { {{Pascal}}CreatedEvent } from '../events/{{kebab}}-created.event.js';
+import { {{Pascal}}DomainException } from '../exceptions/{{kebab}}.exception.js';
+import { {{Pascal}}ErrorCodes } from '@/core/index.js';
+
+export interface {{Pascal}}Props {
+  name: string;
+}
+
+/**
+ * Aggregate root of the {{kebab}} bounded context. Only the aggregate root gets a repository;
+ * child entities are reachable through it.
+ */
+export class {{Pascal}} extends AggregateRoot<{{Pascal}}Props> {
+  static create(name: string, id?: string): {{Pascal}} {
+    {{Pascal}}.assertValidName(name);
+    const entity = new {{Pascal}}({ name: name.trim() }, id);
+    entity.addDomainEvent(new {{Pascal}}CreatedEvent(entity.id, entity.name));
+    return entity;
+  }
+
+  get name(): string {
+    return this.props.name;
+  }
+
+  rename(name: string): void {
+    {{Pascal}}.assertValidName(name);
+    this.props.name = name.trim();
+    this.updatedAt = new Date();
+  }
+
+  private static assertValidName(name: string): void {
+    if (!name || name.trim().length === 0) {
+      throw new {{Pascal}}DomainException({{Pascal}}ErrorCodes.{{CONSTANT}}_INVALID_NAME);
+    }
+  }
+}

package/templates/nest-ddd/files/plop-templates/module/domain/events/{{kebab}}-created.event.ts.hbs

@@ -0,0 +1,10 @@
+import { DomainEvent } from '@/core/index.js';
+
+export class {{Pascal}}CreatedEvent extends DomainEvent {
+  constructor(
+    public readonly aggregateId: string,
+    public readonly name: string,
+  ) {
+    super(aggregateId);
+  }
+}

package/templates/nest-ddd/files/plop-templates/module/domain/exceptions/{{kebab}}.exception.ts.hbs

@@ -0,0 +1,11 @@
+import { DomainException, ErrorCode } from '@/core/index.js';
+
+export class {{Pascal}}DomainException extends DomainException {
+  constructor(error: ErrorCode, customMessage?: string) {
+    super({
+      code: error.code,
+      message: customMessage || error.message,
+      status: error.status,
+    });
+  }
+}

package/templates/nest-ddd/files/plop-templates/module/domain/index.ts.hbs

@@ -0,0 +1,4 @@
+export * from './entities/{{kebab}}.entity.js';
+export * from './events/{{kebab}}-created.event.js';
+export * from './exceptions/{{kebab}}.exception.js';
+export * from './repositories/{{kebab}}.repository.js';

package/templates/nest-ddd/files/plop-templates/module/domain/repositories/{{kebab}}.repository.ts.hbs

@@ -0,0 +1,7 @@
+import { {{Pascal}} } from '../entities/{{kebab}}.entity.js';
+
+/** Port: the domain/application layers depend on this, never on Prisma or any other adapter. */
+export interface I{{Pascal}}Repository {
+  findById(id: string): Promise<{{Pascal}} | null>;
+  save(entity: {{Pascal}}): Promise<void>;
+}

package/templates/nest-ddd/files/plop-templates/module/presentation/controllers/{{kebab}}.controller.ts.hbs

@@ -0,0 +1,53 @@
+import {
+  Controller,
+  Post,
+  Get,
+  Body,
+  Param,
+  HttpCode,
+  HttpStatus,
+} from '@nestjs/common';
+import { CommandBus, QueryBus } from '@nestjs/cqrs';
+import { ApiTags, ApiOperation, ApiResponse, ApiParam } from '@nestjs/swagger';
+import { Create{{Pascal}}Dto } from '../dtos/create-{{kebab}}.dto.js';
+import { {{Pascal}}Mapper } from '../mappers/{{kebab}}.mapper.js';
+import {
+  Create{{Pascal}}Command,
+  Get{{Pascal}}ByIdQuery,
+} from '../../application/index.js';
+import { {{Pascal}} } from '../../domain/index.js';
+
+// Add guards (e.g. @UseGuards(JwtAuthGuard)) once an auth module exists.
+@ApiTags('{{Pascal}}')
+@Controller('{{plural}}')
+export class {{Pascal}}Controller {
+  constructor(
+    private readonly commandBus: CommandBus,
+    private readonly queryBus: QueryBus,
+  ) {}
+
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  @ApiOperation({ summary: 'Create a {{kebab}}' })
+  @ApiResponse({ status: 201, description: '{{Pascal}} created' })
+  @ApiResponse({ status: 400, description: 'Bad Request' })
+  async create(@Body() dto: Create{{Pascal}}Dto) {
+    const {{camel}} = await this.commandBus.execute<Create{{Pascal}}Command, {{Pascal}}>(
+      new Create{{Pascal}}Command(dto.name),
+    );
+    return {{Pascal}}Mapper.toResponse({{camel}});
+  }
+
+  @Get(':id')
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Get a {{kebab}} by ID' })
+  @ApiParam({ name: 'id', description: '{{Pascal}} ID' })
+  @ApiResponse({ status: 200, description: '{{Pascal}} retrieved' })
+  @ApiResponse({ status: 404, description: '{{Pascal}} not found' })
+  async getById(@Param('id') id: string) {
+    const {{camel}} = await this.queryBus.execute<Get{{Pascal}}ByIdQuery, {{Pascal}}>(
+      new Get{{Pascal}}ByIdQuery(id),
+    );
+    return {{Pascal}}Mapper.toResponse({{camel}});
+  }
+}

package/templates/nest-ddd/files/plop-templates/module/presentation/dtos/create-{{kebab}}.dto.ts.hbs

@@ -0,0 +1,10 @@
+import { IsString, IsNotEmpty, MaxLength } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class Create{{Pascal}}Dto {
+  @ApiProperty({ example: 'Sample', maxLength: 100 })
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(100)
+  name: string;
+}

package/templates/nest-ddd/files/plop-templates/module/presentation/dtos/{{kebab}}-response.dto.ts.hbs

@@ -0,0 +1,15 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class {{Pascal}}ResponseDto {
+  @ApiProperty()
+  id: string;
+
+  @ApiProperty()
+  name: string;
+
+  @ApiProperty()
+  createdAt: Date;
+
+  @ApiProperty()
+  updatedAt: Date;
+}

package/templates/nest-ddd/files/plop-templates/module/presentation/index.ts.hbs

@@ -0,0 +1,4 @@
+export * from './controllers/{{kebab}}.controller.js';
+export * from './dtos/create-{{kebab}}.dto.js';
+export * from './dtos/{{kebab}}-response.dto.js';
+export * from './mappers/{{kebab}}.mapper.js';