create-nexwire 4.1.1 → 4.2.0

package/hono/src/framework/maker-cli/module/core.mjs

@@ -5,7 +5,7 @@ import { drizzleGenerateArgs, ensureDatabaseDirectory, ensureMigrationMeta, sync
 import { detectDialect, openApiEnabled } from "../utils/env-db.mjs";
 import { writeFiles } from "../utils/file-ops.mjs";
 import { hasFlag } from "../utils/flags.mjs";
-import { assertName, camelCase, pascal } from "../utils/naming.mjs";
+import { assertName, camelCase, normalizeName, pascal, plural, snakeCase } from "../utils/naming.mjs";
 import { packageScript, runNodeScript } from "../utils/process.mjs";
 
 const stubsRoot = path.resolve(import.meta.dirname, "../stubs");
@@ -18,7 +18,6 @@ const STUBS = {
   },
   controller: {
     openapi: "controller/openapi.ts.stub",
-    openapiWithModel: "controller/openapi.with-model.ts.stub",
     plain: "controller/plain.ts.stub",
     standalone: "controller/standalone.ts.stub"
   },
@@ -36,7 +35,8 @@ const STUBS = {
     }
   },
   seeder: {
-    named: "seeder/name.ts.stub"
+    named: "seeder/name.ts.stub",
+    standalone: "seeder/standalone.ts.stub"
   },
   service: {
     named: "service/name.ts.stub",
@@ -185,6 +185,35 @@ function resolveModuleRef(rawModule, ...flagGroups) {
   return { moduleName, leaf: leafName(moduleName) };
 }
 
+/**
+ * Find an existing module directory whose folder name spells the requested
+ * module differently, only in the separators used (`my_module` vs `my-module`).
+ *
+ * Names are canonicalised to kebab-case, so a module scaffolded before this
+ * happened can live in a folder the canonical name no longer resolves to.
+ * Without this lookup, normalising the name would lock a developer out of their
+ * own module. Matching is segment by segment so a panel path such as
+ * `admin/reporting` keeps working, and each candidate is a real directory
+ * inside src/modules, so the result cannot escape it.
+ */
+async function resolveExistingModuleDir(moduleName) {
+  let current = path.resolve(process.cwd(), "src/modules");
+  for (const segment of moduleName.split("/").filter(Boolean)) {
+    let entries;
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      return "";
+    }
+    const directories = entries.filter((entry) => entry.isDirectory());
+    const exact = directories.find((entry) => entry.name === segment);
+    const loose = exact ?? directories.find((entry) => normalizeName(entry.name) === normalizeName(segment));
+    if (!loose) return "";
+    current = path.join(current, loose.name);
+  }
+  return current;
+}
+
 /** Ensure a module directory exists, throwing a helpful error if not. */
 async function assertModuleExists(moduleName) {
   const root = moduleRoot(moduleName);
@@ -192,6 +221,8 @@ async function assertModuleExists(moduleName) {
   try {
     stats = await fs.stat(root);
   } catch {
+    const legacy = await resolveExistingModuleDir(moduleName);
+    if (legacy) return legacy;
     throw new Error(`Module does not exist: ${moduleName}. Create it first with: bun maker module:make ${moduleName}`);
   }
   if (!stats.isDirectory()) {
@@ -200,14 +231,28 @@ async function assertModuleExists(moduleName) {
   return root;
 }
 
-/** Build the placeholder substitution map shared by module file generators. */
+/**
+ * Build the placeholder substitution map shared by module file generators.
+ *
+ * The same developer-supplied name reaches four different places in a stub, and
+ * each needs a different shape: import paths use the kebab file name, the
+ * service identifier is camelCase, the table identifier is camelCase plural and
+ * the SQL table name is snake_case plural. Deriving all of them from one
+ * canonical name is what keeps a multi-word name from landing in an identifier
+ * position as `game-configService`, which parses as subtraction.
+ */
 function moduleFileVars(moduleName, controller) {
+  const base = normalizeName(controller);
   return {
     module: moduleName,
-    controller,
-    ClassName: pascal(controller),
+    // File name on disk and therefore every import path that points at it.
+    controller: base,
+    // Identifier the stubs export and call.
+    ServiceName: `${camelCase(base)}Service`,
+    ClassName: pascal(base),
     name: leafName(moduleName),
-    tableVariable: `${controller}s`
+    tableName: plural(snakeCase(base)),
+    tableVariable: plural(camelCase(base))
   };
 }
 
@@ -244,8 +289,7 @@ async function serviceFile(moduleName, controllerName, withModel) {
 async function moduleFiles(moduleName, openApi) {
   const name = leafName(moduleName);
   const vars = moduleFileVars(moduleName, name);
-  // The with-model controller variant only exists for the openapi style.
-  const controllerStub = openApi ? STUBS.controller.openapiWithModel : STUBS.controller.plain;
+  const controllerStub = openApi ? STUBS.controller.openapi : STUBS.controller.plain;
   return {
     "facade.ts": await stub(STUBS.facade.named, vars),
     [`controllers/${name}.ts`]: await stub(controllerStub, vars),
@@ -286,25 +330,28 @@ async function standaloneRouteTemplate(moduleName, routeName) {
 
 /** Generate a named model file for a module. */
 async function namedModelTemplate(moduleName, name, dialect) {
+  const base = normalizeName(name);
   return await stub(STUBS.model.named[dialect], {
     module: moduleName,
-    name,
-    controller: name,
-    ClassName: pascal(name),
-    tableName: `${name}s`,
-    tableVariable: `${name}s`
+    name: base,
+    controller: base,
+    ClassName: pascal(base),
+    tableName: plural(snakeCase(base)),
+    tableVariable: plural(camelCase(base))
   });
 }
 
 /** Generate a seeder file for a module model. */
 async function namedSeederTemplate(moduleName, modelName, className) {
+  const base = normalizeName(modelName);
   return await stub(STUBS.seeder.named, {
     module: moduleName,
-    name: modelName,
+    // Import path: the model file is named after the model, in kebab-case.
+    name: base,
     controller: className,
     ClassName: pascal(className),
-    tableName: `${modelName}s`,
-    tableVariable: `${modelName}s`
+    tableName: plural(snakeCase(base)),
+    tableVariable: plural(camelCase(base))
   });
 }
 
@@ -714,7 +761,16 @@ export async function makeModel(rawModule, rawNameOrFlag, extraFlags = []) {
   await writeFileSafe(modelPath, await namedModelTemplate(moduleName, name, dialect), flags, "Model file");
 }
 
-/** Generate a seeder file for an existing module model. */
+/**
+ * Generate a seeder file.
+ *
+ * A seeder does not have to own the table it writes to, and does not have to
+ * write to only one table, so a missing model is not fatal. When the model is
+ * there we import it and pre-wire the insert; when it is not we emit the
+ * standalone shape and let the developer choose what to write. That is the
+ * same trade the controller makes when there is no service, and the service
+ * makes when there is no model. Seeder was the only generator that refused.
+ */
 export async function makeSeeder(rawModule, rawNameOrFlag, extraFlags = []) {
   const { moduleName, leaf } = resolveModuleRef(rawModule, rawNameOrFlag, extraFlags);
   const flags = [];
@@ -725,36 +781,58 @@ export async function makeSeeder(rawModule, rawNameOrFlag, extraFlags = []) {
   }
   flags.push(...extraFlags);
   const root = await assertModuleExists(moduleName);
-  let modelName = name;
-  let modelPath = path.join(root, "database", "models", `${modelName}.ts`);
-
-  try {
-    await fs.access(modelPath);
-  } catch {
-    // Fall back to the module's own model. This must use the leaf, not
-    // moduleName: for a panel module moduleName is "admin/testme", so using it
-    // would probe database/models/admin/testme.ts and never match.
-    modelName = leaf;
-    modelPath = path.join(root, "database", "models", `${modelName}.ts`);
 
-    try {
-      await fs.access(modelPath);
+  // The fallback probes the leaf, not moduleName: for a panel module moduleName
+  // is "admin/testme", so using it would look for database/models/admin/testme.ts
+  // and never match.
+  const modelName = await existingModelName(root, name, leaf);
+  let seeder;
+  if (modelName) {
+    seeder = await namedSeederTemplate(moduleName, modelName, name);
+    if (modelName !== name) {
       console.log(`Model '${name}' not found, using module model '${modelName}' for seeder '${name}'.`);
-    } catch {
-      const panel = panelOf(moduleName);
-      const suggest = panel ? `${leaf} ${name} --path=${panel}` : `${leaf} ${name}`;
-      throw new Error(
-        `Model not found for seeder: src/modules/${moduleName}/database/models/${name}.ts. Create it first with: bun maker module:make-model ${suggest}`
-      );
     }
+  } else {
+    seeder = await stub(STUBS.seeder.standalone, {
+      module: moduleName,
+      name,
+      ClassName: pascal(name),
+      // The stub shows this as the conventional table name, so derive it the
+      // same way the bound stub does - it is what a model of this name exports.
+      tableVariable: plural(camelCase(name))
+    });
+    const available = await listModels(root);
+    console.log(`No model '${name}' in module ${moduleName}, so this is a standalone seeder: it imports no model and writes nothing until you fill it in.`);
+    console.log(
+      available.length
+        ? `  Models in this module: ${available.join(", ")}. Run module:make-seeder ${moduleName} <one of these> for a seeder with the model already imported.`
+        : `  This module has no models yet. Create one with: bun maker module:make-model ${moduleName} ${name}`
+    );
   }
 
-  const seeder = await namedSeederTemplate(moduleName, modelName, name);
   await writeFileSafe(path.join(root, `database/seeders/${name}.ts`), seeder, flags, "Seeder file");
 
   console.log(`Seeder ready: ${moduleName}/${name}`);
 }
 
+/** The model a seeder binds to: the requested one, else the module's own. Null when neither exists. */
+async function existingModelName(root, name, leaf) {
+  for (const candidate of [name, leaf]) {
+    if (await pathExists(path.join(root, "database", "models", `${candidate}.ts`))) return candidate;
+  }
+  return null;
+}
+
+/** Model file names in a module, without the extension. Empty when there are none. */
+async function listModels(root) {
+  try {
+    const entries = await fs.readdir(path.join(root, "database", "models"));
+    return entries.filter((f) => f.endsWith(".ts")).map((f) => f.slice(0, -3));
+  } catch {
+    return [];
+  }
+}
+
 /** Generate a job file for an existing module. */
 export async function makeJob(rawModule, rawNameOrFlag, extraFlags = []) {
   const { moduleName, leaf } = resolveModuleRef(rawModule, rawNameOrFlag, extraFlags);

package/hono/src/framework/maker-cli/runtime/core.mjs

@@ -498,24 +498,42 @@ export async function runVite(configPath) {
   await runCommand(localBin("vite"), ["--config", configPath]);
 }
 
-/** Run Vitest tests (backend). */
+/**
+ * Strip the argument separator npm inserts.
+ *
+ * `npm run maker test -- posts` reaches us as `test posts`, but
+ * `npm run maker test -- -- posts` reaches us as `test -- posts`, because npm
+ * eats one separator and forwards the other. Vitest reads a bare `--` as a
+ * positional filter that matches no test file, which silently runs the whole
+ * suite instead of the one you asked for - so the command appears to work while
+ * doing something else. Dropping a leading `--` makes both spellings behave the
+ * same, and makes the passthrough behave identically across package managers.
+ */
+function vitestArgs(rawArgs) {
+  return rawArgs[0] === "--" ? rawArgs.slice(1) : rawArgs;
+}
+
+/** Run Vitest tests once (backend). */
 export async function runTest(rawArgs = []) {
-  await runCommand(localBin("vitest"), rawArgs);
+  // "run" is required. Bare `vitest` is watch mode, which never exits - so
+  // without this, `maker test` hung in any interactive terminal while CI and
+  // piped runs exited normally, and the two looked identical from a log.
+  await runCommand(localBin("vitest"), ["run", ...vitestArgs(rawArgs)]);
 }
 
 /** Run Vitest in watch mode (backend). */
 export async function runTestWatch(rawArgs = []) {
-  await runCommand(localBin("vitest"), rawArgs);
+  await runCommand(localBin("vitest"), vitestArgs(rawArgs));
 }
 
-/** Run Vitest with coverage (backend). */
+/** Run Vitest once with coverage (backend). */
 export async function runTestCoverage(rawArgs = []) {
-  await runCommand(localBin("vitest"), ["--coverage", ...rawArgs]);
+  await runCommand(localBin("vitest"), ["run", "--coverage", ...vitestArgs(rawArgs)]);
 }
 
 /** Run Vitest in UI mode (backend). */
 export async function runTestUI(rawArgs = []) {
-  await runCommand(localBin("vitest"), ["--ui", ...rawArgs]);
+  await runCommand(localBin("vitest"), ["--ui", ...vitestArgs(rawArgs)]);
 }
 
 /** Clear Vite cache directories. */

package/hono/src/framework/maker-cli/runtime/index.mjs

@@ -1,104 +1,120 @@
-import { clearViteCache, runRuntime, runTest, runTestCoverage, runTestUI, runTestWatch, runUi, runVite } from "./core.mjs";
-
-/** Register runtime commands (dev, serve, queue, schedule, UI tools) on the CLI program. */
-export function registerRuntimeCommands(program, rawArgs) {
-  program
-    .command("dev")
-    .description("Start API + Vue 3 UI plus optional workers/tools")
-    .option("--view <tools>", "Comma-separated UI tools to launch (redis,maildev,studio)")
-    .option("--viewer <tools>", "Alias for --view (npm expands --view to --viewer)")
-    .option("--with <tools>", "Alias for --view")
-    .option("--with-redis-view", "Launch Redis Commander")
-    .option("--with-maildev", "Launch MailDev")
-    .option("--with-db-studio", "Launch Drizzle Studio")
-    .allowUnknownOption(true)
-    .action(async () => runRuntime("dev", rawArgs));
-  program
-    .command("serve")
-    .description("Start HTTP server (dist first if built, else src)")
-    .option("--prod", "Run production build")
-    .option("--runtime <name>", "Runtime: node or bun", "node")
-    .option("--watch", "Watch for file changes (src mode)")
-    .option("--src", "Force source mode even if dist exists")
-    .allowUnknownOption(true)
-    .action(async () => runRuntime("serve", rawArgs));
-  program
-    .command("queue:work")
-    .description("Start queue worker (dist first if built, else src)")
-    .option("--queue <name>", "Queue name", "default")
-    .option("--prod", "Run production build")
-    .option("--runtime <name>", "Runtime: node or bun", "node")
-    .option("--src", "Force source mode even if dist exists")
-    .allowUnknownOption(true)
-    .action(async () => runRuntime("queue:work", rawArgs));
-  program
-    .command("queue:clear")
-    .description("Clear all queue keys")
-    .allowUnknownOption(true)
-    .action(async () => runRuntime("queue:clear", rawArgs));
-  program
-    .command("schedule:work")
-    .description("Start scheduler worker (dist first if built, else src)")
-    .option("--prod", "Run production build")
-    .option("--runtime <name>", "Runtime: node or bun", "node")
-    .option("--src", "Force source mode even if dist exists")
-    .allowUnknownOption(true)
-    .action(async () => runRuntime("schedule:work", rawArgs));
-  program
-    .command("maildev:view")
-    .description("Start MailDev SMTP and web UI")
-    .allowUnknownOption(true)
-    .action(async () => runUi("maildev:view"));
-  program
-    .command("redis:view")
-    .description("Start Redis Commander UI")
-    .allowUnknownOption(true)
-    .action(async () => runUi("redis:view"));
-  program
-    .command("ui:dev")
-    .description("Start Vue 3 UI from src/resources")
-    .allowUnknownOption(true)
-    .action(async () => runVite("src/resources/vite.config.ts"));
-  program
-    .command("admin:dev")
-    .description("Start admin UI dev server")
-    .allowUnknownOption(true)
-    .action(async () => runVite("src/resources/vite.config.ts"));
-  program
-    .command("vite:cache:clear")
-    .description("Clear Vite cache folders (cross-platform)")
-    .allowUnknownOption(true)
-    .action(async () => clearViteCache());
-  program
-    .command("test")
-    .description("Run Vitest backend tests")
-    .allowUnknownOption(true)
-    .action(async () => {
-      const args = process.argv.slice(3);
-      await runTest(args);
-    });
-  program
-    .command("test:watch")
-    .description("Run Vitest backend tests in watch mode")
-    .allowUnknownOption(true)
-    .action(async () => {
-      const args = process.argv.slice(3);
-      await runTestWatch(args);
-    });
-  program
-    .command("test:coverage")
-    .description("Run Vitest backend tests with code coverage")
-    .allowUnknownOption(true)
-    .action(async () => {
-      const args = process.argv.slice(3);
-      await runTestCoverage(args);
-    });
-  program
-    .command("test:ui")
-    .description("Run Vitest backend tests in UI mode")
-    .allowUnknownOption(true)
-    .action(async () => {
-      const args = process.argv.slice(3);
-      await runTestUI(args);
-    });
-}
+import { clearViteCache, runRuntime, runTest, runTestCoverage, runTestUI, runTestWatch, runUi, runVite } from "./core.mjs";
+import { initProjectCommands, PROJECT_COMMANDS_PATH } from "../utils/project-commands.mjs";
+
+/** Register runtime commands (dev, serve, queue, schedule, UI tools) on the CLI program. */
+export function registerRuntimeCommands(program, rawArgs) {
+  program
+    .command("dev")
+    .description("Start API + Vue 3 UI plus optional workers/tools")
+    .option("--view <tools>", "Comma-separated UI tools to launch (redis,maildev,studio)")
+    .option("--viewer <tools>", "Alias for --view (npm expands --view to --viewer)")
+    .option("--with <tools>", "Alias for --view")
+    .option("--with-redis-view", "Launch Redis Commander")
+    .option("--with-maildev", "Launch MailDev")
+    .option("--with-db-studio", "Launch Drizzle Studio")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("dev", rawArgs));
+  program
+    .command("serve")
+    .description("Start HTTP server (dist first if built, else src)")
+    .option("--prod", "Run production build")
+    .option("--runtime <name>", "Runtime: node or bun", "node")
+    .option("--watch", "Watch for file changes (src mode)")
+    .option("--src", "Force source mode even if dist exists")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("serve", rawArgs));
+  program
+    .command("queue:work")
+    .description("Start queue worker (dist first if built, else src)")
+    .option("--queue <name>", "Queue name", "default")
+    .option("--prod", "Run production build")
+    .option("--runtime <name>", "Runtime: node or bun", "node")
+    .option("--src", "Force source mode even if dist exists")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("queue:work", rawArgs));
+  program
+    .command("queue:clear")
+    .description("Clear all queue keys")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("queue:clear", rawArgs));
+  program
+    .command("schedule:work")
+    .description("Start scheduler worker (dist first if built, else src)")
+    .option("--prod", "Run production build")
+    .option("--runtime <name>", "Runtime: node or bun", "node")
+    .option("--src", "Force source mode even if dist exists")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("schedule:work", rawArgs));
+  program
+    .command("maildev:view")
+    .description("Start MailDev SMTP and web UI")
+    .allowUnknownOption(true)
+    .action(async () => runUi("maildev:view"));
+  program
+    .command("redis:view")
+    .description("Start Redis Commander UI")
+    .allowUnknownOption(true)
+    .action(async () => runUi("redis:view"));
+  program
+    .command("ui:dev")
+    .description("Start Vue 3 UI from src/resources")
+    .allowUnknownOption(true)
+    .action(async () => runVite("src/resources/vite.config.ts"));
+  program
+    .command("admin:dev")
+    .description("Start admin UI dev server")
+    .allowUnknownOption(true)
+    .action(async () => runVite("src/resources/vite.config.ts"));
+  program
+    .command("vite:cache:clear")
+    .description("Clear Vite cache folders (cross-platform)")
+    .allowUnknownOption(true)
+    .action(async () => clearViteCache());
+  program
+    .command("maker:init")
+    .description(`Create ${PROJECT_COMMANDS_PATH} for your own commands`)
+    .option("--force", "Overwrite an existing file")
+    .allowUnknownOption(true)
+    .action(async (options) => {
+      const { created, overwritten } = await initProjectCommands(process.cwd(), { force: Boolean(options?.force) });
+      // created = written into a new file; overwritten = replaced under --force.
+      // Neither means the file was already there and was left alone.
+      console.log(
+        created || overwritten
+          ? `Add your commands to ${PROJECT_COMMANDS_PATH}, then run: maker --help`
+          : `${PROJECT_COMMANDS_PATH} already exists and was left alone. Edit it to add commands, or re-run with --force to replace it.`
+      );
+    });
+  program
+    .command("test")
+    .description("Run Vitest backend tests")
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(3);
+      await runTest(args);
+    });
+  program
+    .command("test:watch")
+    .description("Run Vitest backend tests in watch mode")
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(3);
+      await runTestWatch(args);
+    });
+  program
+    .command("test:coverage")
+    .description("Run Vitest backend tests with code coverage")
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(3);
+      await runTestCoverage(args);
+    });
+  program
+    .command("test:ui")
+    .description("Run Vitest backend tests in UI mode")
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(3);
+      await runTestUI(args);
+    });
+}

package/hono/src/framework/maker-cli/stubs/controller/openapi.ts.stub

@@ -1,6 +1,6 @@
 import type { Handler } from "hono";
 import { HttpStatusCodes } from "@/framework/facade.js";
-import { {{controller}}Service } from "@/modules/{{module}}/services/{{controller}}.js";
+import { {{ServiceName}} } from "@/modules/{{module}}/services/{{controller}}.js";
 
 /**
  * Why: Returns every {{controller}} row for list screens.
@@ -8,7 +8,7 @@ import { {{controller}}Service } from "@/modules/{{module}}/services/{{controlle
  * Where: GET /{{controller}} route.
  */
 export const index: Handler = async (c: any) => {
-  const data = await {{controller}}Service.list();
+  const data = await {{ServiceName}}.list();
 
   return c.json({ message: "{{controller}} list fetched successfully", data });
 };
@@ -20,7 +20,7 @@ export const index: Handler = async (c: any) => {
  */
 export const show: Handler = async (c: any) => {
   const { id } = c.req.valid("param");
-  const data = await {{controller}}Service.findOne(id);
+  const data = await {{ServiceName}}.findOne(id);
 
   if (!data) return c.json({ message: "{{controller}} not found" }, HttpStatusCodes.NOT_FOUND);
 
@@ -34,7 +34,7 @@ export const show: Handler = async (c: any) => {
  */
 export const store: Handler = async (c: any) => {
   const body = c.req.valid("json");
-  const data = await {{controller}}Service.create(body);
+  const data = await {{ServiceName}}.create(body);
 
   return c.json({ message: "{{controller}} created successfully", data }, HttpStatusCodes.CREATED);
 };
@@ -47,7 +47,7 @@ export const store: Handler = async (c: any) => {
 export const update: Handler = async (c: any) => {
   const { id } = c.req.valid("param");
   const body = c.req.valid("json");
-  const data = await {{controller}}Service.update(id, body);
+  const data = await {{ServiceName}}.update(id, body);
 
   if (!data) return c.json({ message: "{{controller}} not found" }, HttpStatusCodes.NOT_FOUND);
 
@@ -61,7 +61,7 @@ export const update: Handler = async (c: any) => {
  */
 export const destroy: Handler = async (c: any) => {
   const { id } = c.req.valid("param");
-  const data = await {{controller}}Service.remove(id);
+  const data = await {{ServiceName}}.remove(id);
 
   if (!data) return c.json({ message: "{{controller}} not found" }, HttpStatusCodes.NOT_FOUND);
 

package/hono/src/framework/maker-cli/stubs/controller/plain.ts.stub

@@ -2,7 +2,7 @@ import type { Handler } from "hono";
 import { HttpStatusCodes } from "@/framework/facade.js";
 import { validate } from "@/framework/facade.js";
 import { Create{{ClassName}}Schema, Update{{ClassName}}Schema, {{ClassName}}IdParamsSchema } from "@/modules/{{module}}/schemas/{{controller}}.js";
-import { {{controller}}Service } from "@/modules/{{module}}/services/{{controller}}.js";
+import { {{ServiceName}} } from "@/modules/{{module}}/services/{{controller}}.js";
 
 /**
  * Why: Returns every {{controller}} row for list screens.
@@ -10,7 +10,7 @@ import { {{controller}}Service } from "@/modules/{{module}}/services/{{controlle
  * Where: GET /{{controller}} route.
  */
 export const index: Handler = async (c: any) => {
-  const data = await {{controller}}Service.list();
+  const data = await {{ServiceName}}.list();
 
   return c.json({ message: "{{controller}} list fetched successfully", data });
 };
@@ -22,7 +22,7 @@ export const index: Handler = async (c: any) => {
  */
 export const show: Handler = async (c: any) => {
   const params = await validate({{ClassName}}IdParamsSchema, c.req.param());
-  const data = await {{controller}}Service.findOne(params.id);
+  const data = await {{ServiceName}}.findOne(params.id);
 
   if (!data) return c.json({ message: "{{controller}} not found" }, HttpStatusCodes.NOT_FOUND);
 
@@ -36,7 +36,7 @@ export const show: Handler = async (c: any) => {
  */
 export const store: Handler = async (c: any) => {
   const body = await validate(Create{{ClassName}}Schema, await c.req.json());
-  const data = await {{controller}}Service.create(body);
+  const data = await {{ServiceName}}.create(body);
 
   return c.json({ message: "{{controller}} created successfully", data }, HttpStatusCodes.CREATED);
 };
@@ -49,7 +49,7 @@ export const store: Handler = async (c: any) => {
 export const update: Handler = async (c: any) => {
   const params = await validate({{ClassName}}IdParamsSchema, c.req.param());
   const body = await validate(Update{{ClassName}}Schema, await c.req.json());
-  const data = await {{controller}}Service.update(params.id, body);
+  const data = await {{ServiceName}}.update(params.id, body);
 
   if (!data) return c.json({ message: "{{controller}} not found" }, HttpStatusCodes.NOT_FOUND);
 
@@ -63,7 +63,7 @@ export const update: Handler = async (c: any) => {
  */
 export const destroy: Handler = async (c: any) => {
   const params = await validate({{ClassName}}IdParamsSchema, c.req.param());
-  const data = await {{controller}}Service.remove(params.id);
+  const data = await {{ServiceName}}.remove(params.id);
 
   if (!data) return c.json({ message: "{{controller}} not found" }, HttpStatusCodes.NOT_FOUND);
 

package/hono/src/framework/maker-cli/stubs/helper/name.ts.stub

@@ -9,6 +9,6 @@
  * When: Replace this with real logic and rename it.
  * Where: Anywhere inside the {{module}} module.
  */
-export function {{name}}Helper<T>(value: T): T {
+export function {{Name}}Helper<T>(value: T): T {
   return value;
 }