@fluojs/cli 1.0.0-beta.1

package/dist/generators/manifest.js

@@ -0,0 +1,130 @@
+import { generateControllerFiles } from './controller.js';
+import { generateGuardFiles } from './guard.js';
+import { generateInterceptorFiles } from './interceptor.js';
+import { generateMiddlewareFiles } from './middleware.js';
+import { generateModuleFiles } from './module.js';
+import { generateRepoFiles } from './repository.js';
+import { generateRequestDtoFiles } from './request-dto.js';
+import { generateResponseDtoFiles } from './response-dto.js';
+import { generateServiceFiles } from './service.js';
+export const generatorManifest = [{
+  aliases: ['co'],
+  description: 'Generate a controller (auto-registered in the module controllers array).',
+  factory: (name, options) => generateControllerFiles(name, options),
+  kind: 'controller',
+  moduleRegistration: {
+    arrayKey: 'controllers',
+    classSuffix: 'Controller'
+  },
+  nextStepHint: "Run 'pnpm typecheck' to verify module wiring, then add route handlers.",
+  schematic: 'controller',
+  wiringBehavior: 'auto-registered'
+}, {
+  aliases: ['gu'],
+  description: 'Generate a guard (auto-registered as a provider in the module).',
+  factory: name => generateGuardFiles(name),
+  kind: 'guard',
+  moduleRegistration: {
+    arrayKey: 'providers',
+    classSuffix: 'Guard'
+  },
+  nextStepHint: "Run 'pnpm typecheck' to verify module wiring, then apply the guard to routes.",
+  schematic: 'guard',
+  wiringBehavior: 'auto-registered'
+}, {
+  aliases: ['in'],
+  description: 'Generate an interceptor (auto-registered as a provider in the module).',
+  factory: name => generateInterceptorFiles(name),
+  kind: 'interceptor',
+  moduleRegistration: {
+    arrayKey: 'providers',
+    classSuffix: 'Interceptor'
+  },
+  nextStepHint: "Run 'pnpm typecheck' to verify module wiring, then bind the interceptor to routes.",
+  schematic: 'interceptor',
+  wiringBehavior: 'auto-registered'
+}, {
+  aliases: ['mi'],
+  description: 'Generate a middleware (auto-registered in the module middleware array).',
+  factory: name => generateMiddlewareFiles(name),
+  kind: 'middleware',
+  moduleRegistration: {
+    arrayKey: 'middleware',
+    classSuffix: 'Middleware'
+  },
+  nextStepHint: "Run 'pnpm typecheck' to verify module wiring, then configure route matching in forRoutes.",
+  schematic: 'middleware',
+  wiringBehavior: 'auto-registered'
+}, {
+  aliases: ['mo'],
+  description: 'Generate a standalone module (import it in a parent module to activate).',
+  factory: name => generateModuleFiles(name),
+  kind: 'module',
+  nextStepHint: "Import the new module in a parent module's imports array, then run 'pnpm typecheck'.",
+  schematic: 'module',
+  wiringBehavior: 'files-only'
+}, {
+  aliases: ['repo'],
+  description: 'Generate a persistence-agnostic repository (auto-registered as a provider).',
+  factory: (name, options) => generateRepoFiles(name, options),
+  kind: 'repo',
+  moduleRegistration: {
+    arrayKey: 'providers',
+    classSuffix: 'Repo'
+  },
+  nextStepHint: "Run 'pnpm typecheck' to verify module wiring, then add data-access methods to the repo stub.",
+  registryAliases: ['repository'],
+  schematic: 'repository',
+  wiringBehavior: 'auto-registered'
+}, {
+  aliases: ['req'],
+  description: 'Generate a request DTO for route-level data binding and validation (files only — wire it into a controller manually).',
+  factory: name => generateRequestDtoFiles(name),
+  kind: 'request-dto',
+  nextStepHint: 'Import the DTO in a controller and add it as a parameter with @FromBody or @FromQuery.',
+  schematic: 'request-dto',
+  wiringBehavior: 'files-only'
+}, {
+  aliases: ['res'],
+  description: 'Generate a response DTO for typed response payloads (files only — use it as a controller return type).',
+  factory: name => generateResponseDtoFiles(name),
+  kind: 'response-dto',
+  nextStepHint: 'Import the DTO in a controller and use it as the return type for route handlers.',
+  schematic: 'response-dto',
+  wiringBehavior: 'files-only'
+}, {
+  aliases: ['s'],
+  description: 'Generate a service (auto-registered as a provider in the module).',
+  factory: (name, options) => generateServiceFiles(name, options),
+  kind: 'service',
+  moduleRegistration: {
+    arrayKey: 'providers',
+    classSuffix: 'Service'
+  },
+  nextStepHint: "Run 'pnpm typecheck' to verify module wiring, then implement business logic.",
+  schematic: 'service',
+  wiringBehavior: 'auto-registered'
+}];
+const generatorByKind = new Map();
+const tokenToKind = new Map();
+for (const entry of generatorManifest) {
+  generatorByKind.set(entry.kind, entry);
+  tokenToKind.set(entry.kind, entry.kind);
+  tokenToKind.set(entry.schematic, entry.kind);
+  for (const alias of entry.aliases) {
+    tokenToKind.set(alias, entry.kind);
+  }
+}
+export function findGeneratorDefinition(kind) {
+  const entry = generatorByKind.get(kind);
+  if (!entry) {
+    throw new Error(`Unknown generator kind: ${kind}`);
+  }
+  return entry;
+}
+export function resolveGeneratorKind(value) {
+  if (!value) {
+    return undefined;
+  }
+  return tokenToKind.get(value);
+}

package/dist/generators/middleware.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratedFile } from '../types.js';
+export declare function generateMiddlewareFiles(name: string): GeneratedFile[];
+//# sourceMappingURL=middleware.d.ts.map

package/dist/generators/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/generators/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CASrE"}

package/dist/generators/middleware.js

@@ -0,0 +1,15 @@
+import { renderTemplate } from './render.js';
+import { toKebabCase, toPascalCase } from './utils.js';
+export function generateMiddlewareFiles(name) {
+  const kebab = toKebabCase(name);
+  const resource = toPascalCase(name);
+  const pascal = `${resource}Middleware`;
+  return [{
+    content: renderTemplate('middleware.ts.ejs', {
+      kebab,
+      resource,
+      pascal
+    }),
+    path: `${kebab}.middleware.ts`
+  }];
+}

package/dist/generators/module.d.ts

@@ -0,0 +1,6 @@
+import type { GeneratedFile } from '../types.js';
+import type { ModuleArrayKey } from './manifest.js';
+export declare function ensureModuleImport(source: string, className: string, importPath: string): string;
+export declare function generateModuleFiles(name: string): GeneratedFile[];
+export declare function registerInModule(source: string, arrayKey: ModuleArrayKey, className: string): string;
+//# sourceMappingURL=module.d.ts.map

package/dist/generators/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/generators/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AA6FpD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAyDhG;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CAUjE;AAwDD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpG"}

package/dist/generators/module.js

@@ -0,0 +1,143 @@
+import ts from 'typescript';
+import { renderTemplate } from './render.js';
+import { toKebabCase, toPascalCase } from './utils.js';
+const printer = ts.createPrinter({
+  newLine: ts.NewLineKind.LineFeed
+});
+function parseSource(source) {
+  return ts.createSourceFile('generated.module.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+}
+function getPropertyNameText(name) {
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name)) {
+    return name.text;
+  }
+  return undefined;
+}
+function replaceNodeText(source, sourceFile, node, replacement) {
+  return source.slice(0, node.getStart(sourceFile)) + replacement + source.slice(node.getEnd());
+}
+function findModuleDecoratorObject(sourceFile) {
+  for (const statement of sourceFile.statements) {
+    if (!ts.isClassDeclaration(statement)) {
+      continue;
+    }
+    if (!ts.canHaveDecorators(statement)) {
+      continue;
+    }
+    const decorators = ts.getDecorators(statement);
+    if (!decorators) {
+      continue;
+    }
+    for (const decorator of decorators) {
+      if (!ts.isCallExpression(decorator.expression)) {
+        continue;
+      }
+      if (!ts.isIdentifier(decorator.expression.expression) || decorator.expression.expression.text !== 'Module') {
+        continue;
+      }
+      const [firstArgument] = decorator.expression.arguments;
+      if (firstArgument && ts.isObjectLiteralExpression(firstArgument)) {
+        return firstArgument;
+      }
+    }
+  }
+  return undefined;
+}
+function findNamedImportSource(sourceFile, className) {
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement)) {
+      continue;
+    }
+    const importClause = statement.importClause;
+    if (!importClause?.namedBindings || !ts.isNamedImports(importClause.namedBindings)) {
+      continue;
+    }
+    if (!importClause.namedBindings.elements.some(element => element.name.text === className)) {
+      continue;
+    }
+    if (ts.isStringLiteral(statement.moduleSpecifier)) {
+      return statement.moduleSpecifier.text;
+    }
+  }
+  return undefined;
+}
+function buildImportDeclaration(className, importPath) {
+  return ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(className))])), ts.factory.createStringLiteral(`./${importPath}`));
+}
+export function ensureModuleImport(source, className, importPath) {
+  const sourceFile = parseSource(source);
+  const moduleSpecifier = `./${importPath}`;
+  const existingImportSource = findNamedImportSource(sourceFile, className);
+  if (existingImportSource) {
+    if (existingImportSource === moduleSpecifier) {
+      return source;
+    }
+    throw new Error(`Import collision for ${className}: already imported from "${existingImportSource}" but requested from "${moduleSpecifier}".`);
+  }
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement)) {
+      continue;
+    }
+    if (!ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== moduleSpecifier) {
+      continue;
+    }
+    const importClause = statement.importClause;
+    if (!importClause?.namedBindings || !ts.isNamedImports(importClause.namedBindings)) {
+      continue;
+    }
+    const updatedImport = ts.factory.updateImportDeclaration(statement, statement.modifiers, ts.factory.updateImportClause(importClause, importClause.isTypeOnly, importClause.name, ts.factory.updateNamedImports(importClause.namedBindings, [...importClause.namedBindings.elements, ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(className))])), statement.moduleSpecifier, statement.attributes);
+    return replaceNodeText(source, sourceFile, statement, printer.printNode(ts.EmitHint.Unspecified, updatedImport, sourceFile));
+  }
+  const newImportLine = printer.printNode(ts.EmitHint.Unspecified, buildImportDeclaration(className, importPath), sourceFile);
+  const imports = sourceFile.statements.filter(ts.isImportDeclaration);
+  if (imports.length > 0) {
+    const lastImport = imports[imports.length - 1];
+    return `${source.slice(0, lastImport.getEnd())}\n${newImportLine}${source.slice(lastImport.getEnd())}`;
+  }
+  return `${newImportLine}\n${source}`;
+}
+export function generateModuleFiles(name) {
+  const kebab = toKebabCase(name);
+  const pascal = `${toPascalCase(name)}Module`;
+  return [{
+    content: renderTemplate('module.ts.ejs', {
+      kebab,
+      pascal
+    }),
+    path: `${kebab}.module.ts`
+  }];
+}
+function insertIntoModuleArray(source, arrayKey, className) {
+  const sourceFile = parseSource(source);
+  const moduleMetadata = findModuleDecoratorObject(sourceFile);
+  if (!moduleMetadata) {
+    throw new Error('Unable to locate @Module metadata object in module file.');
+  }
+  let alreadyPresent = false;
+  let hasTargetProperty = false;
+  const updatedProperties = moduleMetadata.properties.map(property => {
+    if (!ts.isPropertyAssignment(property) || getPropertyNameText(property.name) !== arrayKey) {
+      return property;
+    }
+    hasTargetProperty = true;
+    if (!ts.isArrayLiteralExpression(property.initializer)) {
+      throw new Error(`Invalid @Module metadata: "${arrayKey}" must be an array.`);
+    }
+    if (property.initializer.elements.some(element => element.getText(sourceFile) === className)) {
+      alreadyPresent = true;
+      return property;
+    }
+    return ts.factory.updatePropertyAssignment(property, property.name, ts.factory.updateArrayLiteralExpression(property.initializer, [...property.initializer.elements, ts.factory.createIdentifier(className)]));
+  });
+  if (alreadyPresent) {
+    return source;
+  }
+  if (!hasTargetProperty) {
+    updatedProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(arrayKey), ts.factory.createArrayLiteralExpression([ts.factory.createIdentifier(className)], true)));
+  }
+  const updatedModuleMetadata = ts.factory.updateObjectLiteralExpression(moduleMetadata, updatedProperties);
+  return replaceNodeText(source, sourceFile, moduleMetadata, printer.printNode(ts.EmitHint.Unspecified, updatedModuleMetadata, sourceFile));
+}
+export function registerInModule(source, arrayKey, className) {
+  return insertIntoModuleArray(source, arrayKey, className);
+}

package/dist/generators/render.d.ts

@@ -0,0 +1,2 @@
+export declare function renderTemplate(templateName: string, vars: Record<string, unknown>): string;
+//# sourceMappingURL=render.d.ts.map

package/dist/generators/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/generators/render.ts"],"names":[],"mappings":"AAQA,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAU1F"}

package/dist/generators/render.js

@@ -0,0 +1,17 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import ejs from 'ejs';
+const templatesDir = join(dirname(fileURLToPath(import.meta.url)), 'templates');
+const templateCache = new Map();
+export function renderTemplate(templateName, vars) {
+  const templatePath = join(templatesDir, templateName);
+  let template = templateCache.get(templatePath);
+  if (!template) {
+    template = readFileSync(templatePath, 'utf8');
+    templateCache.set(templatePath, template);
+  }
+  return ejs.render(template, vars, {
+    escape: s => String(s)
+  });
+}

package/dist/generators/repository.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateOptions, GeneratedFile } from '../types.js';
+export declare function generateRepoFiles(name: string, _options?: GenerateOptions): GeneratedFile[];
+//# sourceMappingURL=repository.d.ts.map

package/dist/generators/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../src/generators/repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKlE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,eAAoB,GAAG,aAAa,EAAE,CAmB/F"}

package/dist/generators/repository.js

@@ -0,0 +1,29 @@
+import { renderTemplate } from './render.js';
+import { toKebabCase, toPascalCase } from './utils.js';
+export function generateRepoFiles(name, _options = {}) {
+  const kebab = toKebabCase(name);
+  const resource = toPascalCase(name);
+  const pascal = `${resource}Repo`;
+  return [{
+    content: renderTemplate('repository.ts.ejs', {
+      kebab,
+      resource,
+      pascal
+    }),
+    path: `${kebab}.repo.ts`
+  }, {
+    content: renderTemplate('repository.test.ts.ejs', {
+      kebab,
+      resource,
+      pascal
+    }),
+    path: `${kebab}.repo.test.ts`
+  }, {
+    content: renderTemplate('repository.slice.test.ts.ejs', {
+      kebab,
+      resource,
+      pascal
+    }),
+    path: `${kebab}.repo.slice.test.ts`
+  }];
+}

package/dist/generators/request-dto.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratedFile } from '../types.js';
+export declare function generateRequestDtoFiles(name: string): GeneratedFile[];
+//# sourceMappingURL=request-dto.d.ts.map

package/dist/generators/request-dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-dto.d.ts","sourceRoot":"","sources":["../../src/generators/request-dto.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CAYrE"}

package/dist/generators/request-dto.js

@@ -0,0 +1,17 @@
+import { renderTemplate } from './render.js';
+import { toKebabCase, toPascalCase } from './utils.js';
+export function generateRequestDtoFiles(name) {
+  const kebab = toKebabCase(name);
+  const resource = toPascalCase(name);
+  const pascal = `${resource}RequestDto`;
+  const bodyField = resource.charAt(0).toLowerCase() + resource.slice(1);
+  return [{
+    content: renderTemplate('request-dto.ts.ejs', {
+      kebab,
+      resource,
+      pascal,
+      bodyField
+    }),
+    path: `${kebab}.request.dto.ts`
+  }];
+}

package/dist/generators/response-dto.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratedFile } from '../types.js';
+export declare function generateResponseDtoFiles(name: string): GeneratedFile[];
+//# sourceMappingURL=response-dto.d.ts.map

package/dist/generators/response-dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-dto.d.ts","sourceRoot":"","sources":["../../src/generators/response-dto.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CAYtE"}

package/dist/generators/response-dto.js

@@ -0,0 +1,17 @@
+import { renderTemplate } from './render.js';
+import { toKebabCase, toPascalCase } from './utils.js';
+export function generateResponseDtoFiles(name) {
+  const kebab = toKebabCase(name);
+  const resource = toPascalCase(name);
+  const pascal = `${resource}ResponseDto`;
+  const field = resource.charAt(0).toLowerCase() + resource.slice(1);
+  return [{
+    content: renderTemplate('response-dto.ts.ejs', {
+      kebab,
+      resource,
+      pascal,
+      field
+    }),
+    path: `${kebab}.response.dto.ts`
+  }];
+}

package/dist/generators/service.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateOptions, GeneratedFile } from '../types.js';
+export declare function generateServiceFiles(name: string, _options?: GenerateOptions): GeneratedFile[];
+//# sourceMappingURL=service.d.ts.map

package/dist/generators/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/generators/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKlE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,eAAoB,GAAG,aAAa,EAAE,CAkBlG"}

package/dist/generators/service.js

@@ -0,0 +1,22 @@
+import { renderTemplate } from './render.js';
+import { toKebabCase, toPascalCase } from './utils.js';
+export function generateServiceFiles(name, _options = {}) {
+  const kebab = toKebabCase(name);
+  const resource = toPascalCase(name);
+  const pascal = `${resource}Service`;
+  const repo = `${resource}Repo`;
+  const vars = {
+    hasRepo: _options.hasRepo ?? false,
+    kebab,
+    resource,
+    pascal,
+    repo
+  };
+  return [{
+    content: renderTemplate('service.ts.ejs', vars),
+    path: `${kebab}.service.ts`
+  }, {
+    content: renderTemplate('service.test.ts.ejs', vars),
+    path: `${kebab}.service.test.ts`
+  }];
+}

package/dist/generators/templates/controller.test.ts.ejs

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+
+import { <%- pascal %> } from './<%- kebab %>.controller';
+
+<% if (hasService) { %>
+class Fake<%- service %> {
+  async list<%- resource %>s() {
+    return [{ id: '<%- kebab %>-1' }];
+  }
+}
+<% } %>
+
+describe('<%- pascal %>', () => {
+  it('delegates to the service', async () => {
+<% if (hasService) { %>
+    await expect(new <%- pascal %>(new Fake<%- service %>() as never).list<%- resource %>s()).resolves.toEqual([{ id: '<%- kebab %>-1' }]);
+<% } else { %>
+    await expect(new <%- pascal %>().list<%- resource %>s()).resolves.toEqual([]);
+<% } %>
+  });
+});

package/dist/generators/templates/controller.ts.ejs

@@ -0,0 +1,29 @@
+<% if (hasService) { %>
+import { Inject } from '@fluojs/core';
+<% } %>
+import { Controller, Get } from '@fluojs/http';
+
+<% if (hasService) { %>
+import { <%- service %> } from './<%- kebab %>.service';
+<% } %>
+
+@Controller('/<%- kebab %>')
+<% if (hasService) { %>
+@Inject(<%- service %>)
+<% } %>
+class <%- pascal %> {
+<% if (hasService) { %>
+  constructor(private readonly service: <%- service %>) {}
+<% } %>
+
+  @Get('/')
+  async list<%- resource %>s() {
+<% if (hasService) { %>
+    return this.service.list<%- resource %>s();
+<% } else { %>
+    return [];
+<% } %>
+  }
+}
+
+export { <%- pascal %> };

package/dist/generators/templates/guard.ts.ejs

@@ -0,0 +1,7 @@
+import type { Guard, GuardContext } from '@fluojs/http';
+
+export class <%- pascal %> implements Guard {
+  canActivate(context: GuardContext): boolean {
+    return true;
+  }
+}

package/dist/generators/templates/interceptor.ts.ejs

@@ -0,0 +1,7 @@
+import type { CallHandler, Interceptor, InterceptorContext } from '@fluojs/http';
+
+export class <%- pascal %> implements Interceptor {
+  async intercept(context: InterceptorContext, next: CallHandler): Promise<unknown> {
+    return next.handle();
+  }
+}

package/dist/generators/templates/middleware.ts.ejs

@@ -0,0 +1,11 @@
+import type { Middleware, MiddlewareContext, MiddlewareRouteConfig, Next } from '@fluojs/http';
+
+export class <%- pascal %> implements Middleware {
+  static forRoutes(...routes: string[]): MiddlewareRouteConfig {
+    return { middleware: <%- pascal %>, routes };
+  }
+
+  async handle(context: MiddlewareContext, next: Next): Promise<void> {
+    await next();
+  }
+}

package/dist/generators/templates/module.ts.ejs

@@ -0,0 +1,9 @@
+import { Module } from '@fluojs/core';
+
+@Module({
+  controllers: [],
+  providers: [],
+})
+class <%- pascal %> {}
+
+export { <%- pascal %> };

package/dist/generators/templates/repository.slice.test.ts.ejs

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+
+import { createTestingModule } from '@fluojs/testing';
+
+import { <%- resource %>Module } from './<%- kebab %>.module';
+import { <%- pascal %> } from './<%- kebab %>.repo';
+
+describe('<%- pascal %> slice template', () => {
+  it('resolves from the module graph', async () => {
+    const testingModule = await createTestingModule({ rootModule: <%- resource %>Module }).compile();
+    const repo = await testingModule.resolve(<%- pascal %>);
+
+    await expect(repo.list<%- resource %>s()).resolves.toEqual([]);
+  });
+});

package/dist/generators/templates/repository.test.ts.ejs

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest';
+
+import { <%- pascal %> } from './<%- kebab %>.repo';
+
+describe('<%- pascal %>', () => {
+  it('exposes a list method', () => {
+    expect(typeof <%- pascal %>.prototype.list<%- resource %>s).toBe('function');
+  });
+});

package/dist/generators/templates/repository.ts.ejs

@@ -0,0 +1,10 @@
+
+type <%- resource %>Record = {
+  id: string;
+};
+
+export class <%- resource %>Repo {
+  async list<%- resource %>s(): Promise<<%- resource %>Record[]> {
+    return [];
+  }
+}

package/dist/generators/templates/request-dto.ts.ejs

@@ -0,0 +1,9 @@
+import { IsString, MinLength } from '@fluojs/validation';
+import { FromBody } from '@fluojs/http';
+
+export class <%- pascal %> {
+  @FromBody('<%- bodyField %>')
+  @IsString()
+  @MinLength(1, { message: '<%- bodyField %> is required' })
+  <%- bodyField %> = '';
+}

package/dist/generators/templates/response-dto.ts.ejs

@@ -0,0 +1,3 @@
+export class <%- pascal %> {
+  <%- field %>!: string;
+}

package/dist/generators/templates/service.test.ts.ejs

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+
+import { <%- pascal %> } from './<%- kebab %>.service';
+
+<% if (hasRepo) { %>
+class Fake<%- repo %> {
+  list<%- resource %>s() {
+    return [{ id: '<%- kebab %>-1' }];
+  }
+}
+<% } %>
+
+describe('<%- pascal %>', () => {
+  it('delegates to the repo', async () => {
+<% if (hasRepo) { %>
+    await expect(new <%- pascal %>(new Fake<%- repo %>() as never).list<%- resource %>s()).resolves.toEqual([{ id: '<%- kebab %>-1' }]);
+<% } else { %>
+    await expect(new <%- pascal %>().list<%- resource %>s()).resolves.toEqual([]);
+<% } %>
+  });
+});

package/dist/generators/templates/service.ts.ejs

@@ -0,0 +1,24 @@
+<% if (hasRepo) { %>
+import { Inject } from '@fluojs/core';
+<% } %>
+
+<% if (hasRepo) { %>
+import { <%- repo %> } from './<%- kebab %>.repo';
+<% } %>
+
+<% if (hasRepo) { %>
+@Inject(<%- repo %>)
+<% } %>
+export class <%- pascal %> {
+<% if (hasRepo) { %>
+  constructor(private readonly repo: <%- repo %>) {}
+<% } %>
+
+  async list<%- resource %>s() {
+<% if (hasRepo) { %>
+    return this.repo.list<%- resource %>s();
+<% } else { %>
+    return [];
+<% } %>
+  }
+}