core-nails 1.0.1

package/dist/cli/generate/index.d.ts

@@ -0,0 +1 @@
+export declare function runGenerate(args: string[]): Promise<void>;

package/dist/cli/generate/index.js

@@ -0,0 +1,23 @@
+export async function runGenerate(args) {
+    const [type, name] = args;
+    if (!type || !name) {
+        console.error("Usage: nails generate <type> <name>");
+        process.exit(1);
+    }
+    switch (type) {
+        case "model": {
+            const { generateModel } = await import("./model.js");
+            await generateModel(name);
+            break;
+        }
+        case "scaffold": {
+            const { generateScaffold } = await import("./scaffold.js");
+            await generateScaffold(name);
+            break;
+        }
+        default: {
+            console.error(`Unknown generator: ${type}`);
+            process.exit(1);
+        }
+    }
+}

package/dist/cli/generate/model.d.ts

@@ -0,0 +1 @@
+export declare function generateModel(modelName: string): Promise<void>;

package/dist/cli/generate/model.js

@@ -0,0 +1,61 @@
+import fs from "fs";
+import path from "path";
+import pluralize from "pluralize";
+export async function generateModel(modelName) {
+    if (!modelName) {
+        console.error("Usage: yarn generate model <ModelName>");
+        console.error("Example: yarn generate model UserActivity");
+        process.exit(1);
+    }
+    // Convert model name to match filename conventions
+    const dirName = path.join("app", "(model)", modelName);
+    const filePath = path.join(dirName, "index.ts");
+    // Pluralize collection name
+    const collectionName = pluralize(modelName.charAt(0).toLowerCase() + modelName.slice(1));
+    // Boilerplate content for model
+    const modelContent = `import CreateService from "../concerns/CreateService";
+import { ${modelName}Schema } from "@schema";
+
+const ${modelName} = CreateService({
+  collection: "${collectionName}",
+  schema: ${modelName}Schema,
+});
+
+export default ${modelName};
+`;
+    // Create model directory and write index.ts
+    fs.mkdirSync(dirName, { recursive: true });
+    fs.writeFileSync(filePath, modelContent);
+    console.log(`create  ${path.relative(process.cwd(), filePath)}`);
+    // --- Append schema stub to db/schema.ts ---
+    const dbDir = path.join("db");
+    fs.mkdirSync(dbDir, { recursive: true });
+    const schemaFilePath = path.join(dbDir, "schema.ts");
+    const schemaBaseContent = `import FirebaseAdmin from "@lib/FirebaseAdmin";
+import { z } from "zod";
+
+// Helper Function
+const FirebaseTimestamp = z.union([
+  z.instanceof(FirebaseAdmin.firestore.Timestamp),
+  z.date(),
+  z.custom((val) => val === FirebaseAdmin.firestore.FieldValue.serverTimestamp(), { message: "Expected serverTimestamp()" }),
+]);
+`;
+    // Ensure schema file exists
+    if (!fs.existsSync(schemaFilePath)) {
+        fs.writeFileSync(schemaFilePath, schemaBaseContent);
+        console.log(`create  ${path.relative(process.cwd(), schemaFilePath)}`);
+    }
+    else {
+        console.log(`append  ${path.relative(process.cwd(), schemaFilePath)}`);
+    }
+    const schemaStub = `
+// ${modelName} Schema
+export const ${modelName}Schema = z.object({
+  createdAt: FirebaseTimestamp.optional(),
+  updatedAt: FirebaseTimestamp.optional(),
+});
+export type ${modelName}Type = z.infer<typeof ${modelName}Schema>;
+`;
+    fs.appendFileSync(schemaFilePath, schemaStub);
+}

package/dist/cli/generate/scaffold.d.ts

@@ -0,0 +1 @@
+export declare function generateScaffold(scaffoldName: string): Promise<void>;

package/dist/cli/generate/scaffold.js

@@ -0,0 +1,105 @@
+import fs from "fs";
+import path from "path";
+import pluralize from "pluralize";
+import { generateModel } from "./model.js";
+export async function generateScaffold(scaffoldName) {
+    if (!scaffoldName) {
+        console.error("Usage: yarn generate scaffold <ScaffoldName>");
+        console.error("Example: yarn generate scaffold UserActivity");
+        process.exit(1);
+    }
+    function toSnakeCase(name) {
+        const snake = name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+        return pluralize(snake);
+    }
+    const camelName = scaffoldName.charAt(0).toUpperCase() + scaffoldName.slice(1);
+    const snakePluralName = toSnakeCase(scaffoldName);
+    // --- 1️⃣ Generate Model (if missing) ---
+    const modelDir = path.join("app", "(model)", camelName);
+    if (!fs.existsSync(modelDir)) {
+        console.log(`Model not found for ${camelName}, generating...`);
+        await generateModel(scaffoldName);
+    }
+    // --- 2️⃣ Paths ---
+    const controllerDir = path.join("app", "(controller)", camelName);
+    const apiDir = path.join("app", "api", snakePluralName);
+    const apiIdDir = path.join(apiDir, "[id]");
+    // --- 3️⃣ Action files ---
+    const actions = ["index", "show", "create", "update", "destroy"];
+    fs.mkdirSync(controllerDir, { recursive: true });
+    const actionsDir = path.join(controllerDir, "actions");
+    fs.mkdirSync(actionsDir, { recursive: true });
+    actions.forEach((action) => {
+        const filePath = path.join(actionsDir, `${action}_action.ts`);
+        const content = `export default async function ${action}_action(req: Request${["index", "create"].includes(action) ? "" : ", id: string"}) {
+  return new Response(JSON.stringify({ message: "${action} ${camelName}" }));
+}
+`;
+        fs.writeFileSync(filePath, content);
+        console.log(`create  ${path.relative(process.cwd(), filePath)}`);
+    });
+    // --- 4️⃣ controller index.ts ---
+    const indexContent = actions
+        .map((action) => `import ${action}_action from "./actions/${action}_action";`)
+        .join("\n") +
+        `
+
+export default {
+${actions.map((a) => `  ${a}_action,`).join("\n")}
+};
+`;
+    const controllerIndexPath = path.join(controllerDir, "index.ts");
+    fs.writeFileSync(controllerIndexPath, indexContent);
+    console.log(`create  ${path.relative(process.cwd(), controllerIndexPath)}`);
+    // --- 5️⃣ API route.ts ---
+    fs.mkdirSync(apiDir, { recursive: true });
+    const apiRoutePath = path.join(apiDir, "route.ts");
+    const apiRouteContent = `/**
+ * Standard RESTful Routes
+ *
+ * | HTTP Verb | Controller#Action | Purpose          | Path                                       |
+ * |-----------|-------------------|------------------|--------------------------------------------|
+ * | GET       | index             | List all         | /${snakePluralName}
+ * | GET       | show              | Get one          | /${snakePluralName}/:id
+ * | POST      | create            | Create           | /${snakePluralName}
+ * | PATCH     | update            | Update (partial) | /${snakePluralName}/:id
+ * | PUT       | update            | Update (full)    | /${snakePluralName}/:id
+ * | DELETE    | destroy           | Delete           | /${snakePluralName}/:id
+ */
+
+import ${camelName}Controller from "@controller/${camelName}";
+
+export async function GET(req: Request) {
+  return ${camelName}Controller.index_action(req);
+}
+
+export async function POST(req: Request) {
+  return ${camelName}Controller.create_action(req);
+}
+`;
+    fs.writeFileSync(apiRoutePath, apiRouteContent);
+    console.log(`create  ${path.relative(process.cwd(), apiRoutePath)}`);
+    // --- 6️⃣ API [id]/route.ts ---
+    fs.mkdirSync(apiIdDir, { recursive: true });
+    const apiIdRoutePath = path.join(apiIdDir, "route.ts");
+    const apiIdRouteContent = `import ${camelName}Controller from "@controller/${camelName}";
+
+export async function GET(req: Request, { params }: { params: { id: string } }) {
+  return ${camelName}Controller.show_action(req, params.id);
+}
+
+export async function PATCH(req: Request, { params }: { params: { id: string } }) {
+  return ${camelName}Controller.update_action(req, params.id);
+}
+
+export async function PUT(req: Request, { params }: { params: { id: string } }) {
+  return ${camelName}Controller.update_action(req, params.id);
+}
+
+export async function DELETE(req: Request, { params }: { params: { id: string } }) {
+  return ${camelName}Controller.destroy_action(req, params.id);
+}
+`;
+    fs.writeFileSync(apiIdRoutePath, apiIdRouteContent);
+    console.log(`create  ${path.relative(process.cwd(), apiIdRoutePath)}`);
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+declare const command: string, args: string[];
+declare function run(): Promise<void>;

package/dist/cli/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+"use strict";
+const [, , command, ...args] = process.argv;
+async function run() {
+    switch (command) {
+        case "generate": {
+            const { runGenerate } = await import("./generate/index.js");
+            await runGenerate(args);
+            break;
+        }
+        default: {
+            console.log(`Unknown command: ${command}`);
+            console.log("Available commands: generate");
+            process.exit(1);
+        }
+    }
+}
+run();

package/dist/src/cli/generate/index.d.ts

@@ -0,0 +1 @@
+export declare function runGenerate(args: string[]): Promise<void>;

package/dist/src/cli/generate/index.js

@@ -0,0 +1,23 @@
+export async function runGenerate(args) {
+    const [type, name] = args;
+    if (!type || !name) {
+        console.error("Usage: nails generate <type> <name>");
+        process.exit(1);
+    }
+    switch (type) {
+        case "model": {
+            const { generateModel } = await import("./model.js");
+            await generateModel(name);
+            break;
+        }
+        case "scaffold": {
+            const { generateScaffold } = await import("./scaffold.js");
+            await generateScaffold(name);
+            break;
+        }
+        default: {
+            console.error(`Unknown generator: ${type}`);
+            process.exit(1);
+        }
+    }
+}

package/dist/src/cli/generate/model.d.ts

@@ -0,0 +1 @@
+export declare function generateModel(modelName: string): Promise<void>;

package/dist/src/cli/generate/model.js

@@ -0,0 +1,61 @@
+import fs from "fs";
+import path from "path";
+import pluralize from "pluralize";
+export async function generateModel(modelName) {
+    if (!modelName) {
+        console.error("Usage: yarn generate model <ModelName>");
+        console.error("Example: yarn generate model UserActivity");
+        process.exit(1);
+    }
+    // Convert model name to match filename conventions
+    const dirName = path.join("app", "(model)", modelName);
+    const filePath = path.join(dirName, "index.ts");
+    // Pluralize collection name
+    const collectionName = pluralize(modelName.charAt(0).toLowerCase() + modelName.slice(1));
+    // Boilerplate content for model
+    const modelContent = `import CreateService from "../concerns/CreateService";
+import { ${modelName}Schema } from "@schema";
+
+const ${modelName} = CreateService({
+  collection: "${collectionName}",
+  schema: ${modelName}Schema,
+});
+
+export default ${modelName};
+`;
+    // Create model directory and write index.ts
+    fs.mkdirSync(dirName, { recursive: true });
+    fs.writeFileSync(filePath, modelContent);
+    console.log(`create  ${path.relative(process.cwd(), filePath)}`);
+    // --- Append schema stub to db/schema.ts ---
+    const dbDir = path.join("db");
+    fs.mkdirSync(dbDir, { recursive: true });
+    const schemaFilePath = path.join(dbDir, "schema.ts");
+    const schemaBaseContent = `import FirebaseAdmin from "@lib/FirebaseAdmin";
+import { z } from "zod";
+
+// Helper Function
+const FirebaseTimestamp = z.union([
+  z.instanceof(FirebaseAdmin.firestore.Timestamp),
+  z.date(),
+  z.custom((val) => val === FirebaseAdmin.firestore.FieldValue.serverTimestamp(), { message: "Expected serverTimestamp()" }),
+]);
+`;
+    // Ensure schema file exists
+    if (!fs.existsSync(schemaFilePath)) {
+        fs.writeFileSync(schemaFilePath, schemaBaseContent);
+        console.log(`create  ${path.relative(process.cwd(), schemaFilePath)}`);
+    }
+    else {
+        console.log(`append  ${path.relative(process.cwd(), schemaFilePath)}`);
+    }
+    const schemaStub = `
+// ${modelName} Schema
+export const ${modelName}Schema = z.object({
+  createdAt: FirebaseTimestamp.optional(),
+  updatedAt: FirebaseTimestamp.optional(),
+});
+export type ${modelName}Type = z.infer<typeof ${modelName}Schema>;
+`;
+    fs.appendFileSync(schemaFilePath, schemaStub);
+}

package/dist/src/cli/generate/scaffold.d.ts

@@ -0,0 +1 @@
+export declare function generateScaffold(scaffoldName: string): Promise<void>;

package/dist/src/cli/generate/scaffold.js

@@ -0,0 +1,105 @@
+import fs from "fs";
+import path from "path";
+import pluralize from "pluralize";
+import { generateModel } from "./model.js";
+export async function generateScaffold(scaffoldName) {
+    if (!scaffoldName) {
+        console.error("Usage: yarn generate scaffold <ScaffoldName>");
+        console.error("Example: yarn generate scaffold UserActivity");
+        process.exit(1);
+    }
+    function toSnakeCase(name) {
+        const snake = name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+        return pluralize(snake);
+    }
+    const camelName = scaffoldName.charAt(0).toUpperCase() + scaffoldName.slice(1);
+    const snakePluralName = toSnakeCase(scaffoldName);
+    // --- 1️⃣ Generate Model (if missing) ---
+    const modelDir = path.join("app", "(model)", camelName);
+    if (!fs.existsSync(modelDir)) {
+        console.log(`Model not found for ${camelName}, generating...`);
+        await generateModel(scaffoldName);
+    }
+    // --- 2️⃣ Paths ---
+    const controllerDir = path.join("app", "(controller)", camelName);
+    const apiDir = path.join("app", "api", snakePluralName);
+    const apiIdDir = path.join(apiDir, "[id]");
+    // --- 3️⃣ Action files ---
+    const actions = ["index", "show", "create", "update", "destroy"];
+    fs.mkdirSync(controllerDir, { recursive: true });
+    const actionsDir = path.join(controllerDir, "actions");
+    fs.mkdirSync(actionsDir, { recursive: true });
+    actions.forEach((action) => {
+        const filePath = path.join(actionsDir, `${action}_action.ts`);
+        const content = `export default async function ${action}_action(req: Request${["index", "create"].includes(action) ? "" : ", id: string"}) {
+  return new Response(JSON.stringify({ message: "${action} ${camelName}" }));
+}
+`;
+        fs.writeFileSync(filePath, content);
+        console.log(`create  ${path.relative(process.cwd(), filePath)}`);
+    });
+    // --- 4️⃣ controller index.ts ---
+    const indexContent = actions
+        .map((action) => `import ${action}_action from "./actions/${action}_action";`)
+        .join("\n") +
+        `
+
+export default {
+${actions.map((a) => `  ${a}_action,`).join("\n")}
+};
+`;
+    const controllerIndexPath = path.join(controllerDir, "index.ts");
+    fs.writeFileSync(controllerIndexPath, indexContent);
+    console.log(`create  ${path.relative(process.cwd(), controllerIndexPath)}`);
+    // --- 5️⃣ API route.ts ---
+    fs.mkdirSync(apiDir, { recursive: true });
+    const apiRoutePath = path.join(apiDir, "route.ts");
+    const apiRouteContent = `/**
+ * Standard RESTful Routes
+ *
+ * | HTTP Verb | Controller#Action | Purpose          | Path                                       |
+ * |-----------|-------------------|------------------|--------------------------------------------|
+ * | GET       | index             | List all         | /${snakePluralName}
+ * | GET       | show              | Get one          | /${snakePluralName}/:id
+ * | POST      | create            | Create           | /${snakePluralName}
+ * | PATCH     | update            | Update (partial) | /${snakePluralName}/:id
+ * | PUT       | update            | Update (full)    | /${snakePluralName}/:id
+ * | DELETE    | destroy           | Delete           | /${snakePluralName}/:id
+ */
+
+import ${camelName}Controller from "@controller/${camelName}";
+
+export async function GET(req: Request) {
+  return ${camelName}Controller.index_action(req);
+}
+
+export async function POST(req: Request) {
+  return ${camelName}Controller.create_action(req);
+}
+`;
+    fs.writeFileSync(apiRoutePath, apiRouteContent);
+    console.log(`create  ${path.relative(process.cwd(), apiRoutePath)}`);
+    // --- 6️⃣ API [id]/route.ts ---
+    fs.mkdirSync(apiIdDir, { recursive: true });
+    const apiIdRoutePath = path.join(apiIdDir, "route.ts");
+    const apiIdRouteContent = `import ${camelName}Controller from "@controller/${camelName}";
+
+export async function GET(req: Request, { params }: { params: { id: string } }) {
+  return ${camelName}Controller.show_action(req, params.id);
+}
+
+export async function PATCH(req: Request, { params }: { params: { id: string } }) {
+  return ${camelName}Controller.update_action(req, params.id);
+}
+
+export async function PUT(req: Request, { params }: { params: { id: string } }) {
+  return ${camelName}Controller.update_action(req, params.id);
+}
+
+export async function DELETE(req: Request, { params }: { params: { id: string } }) {
+  return ${camelName}Controller.destroy_action(req, params.id);
+}
+`;
+    fs.writeFileSync(apiIdRoutePath, apiIdRouteContent);
+    console.log(`create  ${path.relative(process.cwd(), apiIdRoutePath)}`);
+}

package/dist/src/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+declare const command: any, args: any;
+declare function run(): Promise<void>;

package/dist/src/cli/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+"use strict";
+const [, , command, ...args] = process.argv;
+async function run() {
+    switch (command) {
+        case "generate": {
+            const { runGenerate } = await import("./generate/index.js");
+            await runGenerate(args);
+            break;
+        }
+        default: {
+            console.log(`Unknown command: ${command}`);
+            console.log("Available commands: generate");
+            process.exit(1);
+        }
+    }
+}
+run();

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "core-nails",
+  "version": "1.0.1",
+  "scripts": {
+    "build": "tsc"
+  },
+  "bin": {
+    "nails": "dist/cli/index.js"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@types/pluralize": "^0.0.33",
+    "typescript": "^6.0.2"
+  },
+  "dependencies": {
+    "pluralize": "^8.0.0"
+  }
+}

package/src/cli/generate/index.ts

@@ -0,0 +1,27 @@
+export async function runGenerate(args: string[]) {
+  const [type, name] = args;
+
+  if (!type || !name) {
+    console.error("Usage: nails generate <type> <name>");
+    process.exit(1);
+  }
+
+  switch (type) {
+    case "model": {
+      const { generateModel } = await import("./model.js");
+      await generateModel(name);
+      break;
+    }
+
+    case "scaffold": {
+      const { generateScaffold } = await import("./scaffold.js");
+      await generateScaffold(name);
+      break;
+    }
+
+    default: {
+      console.error(`Unknown generator: ${type}`);
+      process.exit(1);
+    }
+  }
+}

package/src/cli/generate/model.ts

@@ -0,0 +1,73 @@
+import fs from "fs";
+import path from "path";
+import pluralize from "pluralize";
+
+export async function generateModel(modelName: string) {
+  if (!modelName) {
+    console.error("Usage: yarn generate model <ModelName>");
+    console.error("Example: yarn generate model UserActivity");
+    process.exit(1);
+  }
+
+  // Convert model name to match filename conventions
+  const dirName = path.join("app", "(model)", modelName);
+  const filePath = path.join(dirName, "index.ts");
+
+  // Pluralize collection name
+  const collectionName = pluralize(
+    modelName.charAt(0).toLowerCase() + modelName.slice(1)
+  );
+
+  // Boilerplate content for model
+  const modelContent = `import CreateService from "../concerns/CreateService";
+import { ${modelName}Schema } from "@schema";
+
+const ${modelName} = CreateService({
+  collection: "${collectionName}",
+  schema: ${modelName}Schema,
+});
+
+export default ${modelName};
+`;
+
+  // Create model directory and write index.ts
+  fs.mkdirSync(dirName, { recursive: true });
+  fs.writeFileSync(filePath, modelContent);
+
+  console.log(`create  ${path.relative(process.cwd(), filePath)}`);
+
+  // --- Append schema stub to db/schema.ts ---
+  const dbDir = path.join("db");
+  fs.mkdirSync(dbDir, { recursive: true });
+  const schemaFilePath = path.join(dbDir, "schema.ts");
+
+  const schemaBaseContent = `import FirebaseAdmin from "@lib/FirebaseAdmin";
+import { z } from "zod";
+
+// Helper Function
+const FirebaseTimestamp = z.union([
+  z.instanceof(FirebaseAdmin.firestore.Timestamp),
+  z.date(),
+  z.custom((val) => val === FirebaseAdmin.firestore.FieldValue.serverTimestamp(), { message: "Expected serverTimestamp()" }),
+]);
+`;
+
+  // Ensure schema file exists
+  if (!fs.existsSync(schemaFilePath)) {
+    fs.writeFileSync(schemaFilePath, schemaBaseContent);
+    console.log(`create  ${path.relative(process.cwd(), schemaFilePath)}`);
+  } else {
+    console.log(`append  ${path.relative(process.cwd(), schemaFilePath)}`);
+  }
+
+  const schemaStub = `
+// ${modelName} Schema
+export const ${modelName}Schema = z.object({
+  createdAt: FirebaseTimestamp.optional(),
+  updatedAt: FirebaseTimestamp.optional(),
+});
+export type ${modelName}Type = z.infer<typeof ${modelName}Schema>;
+`;
+
+  fs.appendFileSync(schemaFilePath, schemaStub);
+}

package/src/cli/generate/scaffold.ts

@@ -0,0 +1,134 @@
+import fs from "fs";
+import path from "path";
+import pluralize from "pluralize";
+import { generateModel } from "./model.js";
+
+export async function generateScaffold(scaffoldName: string) {
+  if (!scaffoldName) {
+    console.error("Usage: yarn generate scaffold <ScaffoldName>");
+    console.error("Example: yarn generate scaffold UserActivity");
+    process.exit(1);
+  }
+
+  function toSnakeCase(name: string) {
+    const snake = name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+    return pluralize(snake);
+  }
+
+  const camelName =
+    scaffoldName.charAt(0).toUpperCase() + scaffoldName.slice(1);
+
+  const snakePluralName = toSnakeCase(scaffoldName);
+
+  // --- 1️⃣ Generate Model (if missing) ---
+  const modelDir = path.join("app", "(model)", camelName);
+
+  if (!fs.existsSync(modelDir)) {
+    console.log(`Model not found for ${camelName}, generating...`);
+    await generateModel(scaffoldName);
+  }
+
+  // --- 2️⃣ Paths ---
+  const controllerDir = path.join("app", "(controller)", camelName);
+  const apiDir = path.join("app", "api", snakePluralName);
+  const apiIdDir = path.join(apiDir, "[id]");
+
+  // --- 3️⃣ Action files ---
+  const actions = ["index", "show", "create", "update", "destroy"];
+
+  fs.mkdirSync(controllerDir, { recursive: true });
+  const actionsDir = path.join(controllerDir, "actions");
+  fs.mkdirSync(actionsDir, { recursive: true });
+
+  actions.forEach((action) => {
+    const filePath = path.join(actionsDir, `${action}_action.ts`);
+
+    const content = `export default async function ${action}_action(req: Request${["index", "create"].includes(action) ? "" : ", id: string"}) {
+  return new Response(JSON.stringify({ message: "${action} ${camelName}" }));
+}
+`;
+
+    fs.writeFileSync(filePath, content);
+    console.log(`create  ${path.relative(process.cwd(), filePath)}`);
+  });
+
+  // --- 4️⃣ controller index.ts ---
+  const indexContent =
+    actions
+      .map(
+        (action) =>
+          `import ${action}_action from "./actions/${action}_action";`
+      )
+      .join("\n") +
+    `
+
+export default {
+${actions.map((a) => `  ${a}_action,`).join("\n")}
+};
+`;
+
+  const controllerIndexPath = path.join(controllerDir, "index.ts");
+  fs.writeFileSync(controllerIndexPath, indexContent);
+  console.log(
+    `create  ${path.relative(process.cwd(), controllerIndexPath)}`
+  );
+
+  // --- 5️⃣ API route.ts ---
+  fs.mkdirSync(apiDir, { recursive: true });
+
+  const apiRoutePath = path.join(apiDir, "route.ts");
+
+  const apiRouteContent = `/**
+ * Standard RESTful Routes
+ *
+ * | HTTP Verb | Controller#Action | Purpose          | Path                                       |
+ * |-----------|-------------------|------------------|--------------------------------------------|
+ * | GET       | index             | List all         | /${snakePluralName}
+ * | GET       | show              | Get one          | /${snakePluralName}/:id
+ * | POST      | create            | Create           | /${snakePluralName}
+ * | PATCH     | update            | Update (partial) | /${snakePluralName}/:id
+ * | PUT       | update            | Update (full)    | /${snakePluralName}/:id
+ * | DELETE    | destroy           | Delete           | /${snakePluralName}/:id
+ */
+
+import ${camelName}Controller from "@controller/${camelName}";
+
+export async function GET(req: Request) {
+  return ${camelName}Controller.index_action(req);
+}
+
+export async function POST(req: Request) {
+  return ${camelName}Controller.create_action(req);
+}
+`;
+
+  fs.writeFileSync(apiRoutePath, apiRouteContent);
+  console.log(`create  ${path.relative(process.cwd(), apiRoutePath)}`);
+
+  // --- 6️⃣ API [id]/route.ts ---
+  fs.mkdirSync(apiIdDir, { recursive: true });
+
+  const apiIdRoutePath = path.join(apiIdDir, "route.ts");
+
+  const apiIdRouteContent = `import ${camelName}Controller from "@controller/${camelName}";
+
+export async function GET(req: Request, { params }: { params: { id: string } }) {
+  return ${camelName}Controller.show_action(req, params.id);
+}
+
+export async function PATCH(req: Request, { params }: { params: { id: string } }) {
+  return ${camelName}Controller.update_action(req, params.id);
+}
+
+export async function PUT(req: Request, { params }: { params: { id: string } }) {
+  return ${camelName}Controller.update_action(req, params.id);
+}
+
+export async function DELETE(req: Request, { params }: { params: { id: string } }) {
+  return ${camelName}Controller.destroy_action(req, params.id);
+}
+`;
+
+  fs.writeFileSync(apiIdRoutePath, apiIdRouteContent);
+  console.log(`create  ${path.relative(process.cwd(), apiIdRoutePath)}`);
+}

package/src/cli/index.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+const [, , command, ...args] = process.argv;
+
+async function run() {
+  switch (command) {
+    case "generate": {
+      const { runGenerate } = await import("./generate/index.js");
+      await runGenerate(args);
+      break;
+    }
+
+    default: {
+      console.log(`Unknown command: ${command}`);
+      console.log("Available commands: generate");
+      process.exit(1);
+    }
+  }
+}
+
+run();

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "module": "ESNext",
+    "target": "ES2020",
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "declaration": true,
+    "strict": true,
+    "ignoreDeprecations": "6.0",
+    "types": ["node"]
+  },
+  "include": ["src"]
+}