nextjs-drizzle-gen 0.1.1 → 0.2.0

package/README.md

@@ -1,7 +1,14 @@
 # nextjs-drizzle-gen
 
+[![CI](https://github.com/mantaskaveckas/nextjs-drizzle-gen/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/mantaskaveckas/nextjs-drizzle-gen/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/nextjs-drizzle-gen)](https://www.npmjs.com/package/nextjs-drizzle-gen)
+[![npm downloads](https://img.shields.io/npm/dm/nextjs-drizzle-gen)](https://www.npmjs.com/package/nextjs-drizzle-gen)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 Rails-like generators for Next.js + Drizzle ORM projects. Generate models, server actions, CRUD pages, and API routes with a single command.
 
+[**Documentation**](https://mantaskaveckas.github.io/nextjs-drizzle-gen/)
+
 ## Installation
 
 ```bash

package/dist/index.js

@@ -4,11 +4,9 @@
 import { program } from "commander";
 
 // src/generators/model.ts
-import * as path2 from "path";
+import * as path4 from "path";
 
-// src/utils.ts
-import * as fs from "fs";
-import * as path from "path";
+// src/lib/types.ts
 var VALID_FIELD_TYPES = [
   "string",
   "text",
@@ -25,6 +23,11 @@ var VALID_FIELD_TYPES = [
   "json",
   "uuid"
 ];
+
+// src/lib/config.ts
+import * as fs from "fs";
+import * as path from "path";
+var cachedProjectConfig = null;
 function detectDialect() {
   const configPath = path.join(process.cwd(), "drizzle.config.ts");
   if (!fs.existsSync(configPath)) {
@@ -43,7 +46,6 @@ function detectDialect() {
   }
   return "sqlite";
 }
-var cachedProjectConfig = null;
 function detectProjectConfig() {
   if (cachedProjectConfig) {
     return cachedProjectConfig;
@@ -98,37 +100,40 @@ function getDbPath() {
   const config = detectProjectConfig();
   return path.join(process.cwd(), config.dbPath);
 }
+
+// src/lib/logger.ts
+import * as path2 from "path";
 var log = {
   create: (filePath) => {
-    const relative2 = path.relative(process.cwd(), filePath);
+    const relative2 = path2.relative(process.cwd(), filePath);
     console.log(`      \x1B[32mcreate\x1B[0m  ${relative2}`);
   },
   force: (filePath) => {
-    const relative2 = path.relative(process.cwd(), filePath);
+    const relative2 = path2.relative(process.cwd(), filePath);
     console.log(`       \x1B[33mforce\x1B[0m  ${relative2}`);
   },
   skip: (filePath) => {
-    const relative2 = path.relative(process.cwd(), filePath);
+    const relative2 = path2.relative(process.cwd(), filePath);
     console.log(`        \x1B[33mskip\x1B[0m  ${relative2}`);
   },
   remove: (filePath) => {
-    const relative2 = path.relative(process.cwd(), filePath);
+    const relative2 = path2.relative(process.cwd(), filePath);
     console.log(`      \x1B[31mremove\x1B[0m  ${relative2}`);
   },
   notFound: (filePath) => {
-    const relative2 = path.relative(process.cwd(), filePath);
+    const relative2 = path2.relative(process.cwd(), filePath);
     console.log(`   \x1B[33mnot found\x1B[0m  ${relative2}`);
   },
   wouldCreate: (filePath) => {
-    const relative2 = path.relative(process.cwd(), filePath);
+    const relative2 = path2.relative(process.cwd(), filePath);
     console.log(`\x1B[36mwould create\x1B[0m  ${relative2}`);
   },
   wouldForce: (filePath) => {
-    const relative2 = path.relative(process.cwd(), filePath);
+    const relative2 = path2.relative(process.cwd(), filePath);
     console.log(` \x1B[36mwould force\x1B[0m  ${relative2}`);
   },
   wouldRemove: (filePath) => {
-    const relative2 = path.relative(process.cwd(), filePath);
+    const relative2 = path2.relative(process.cwd(), filePath);
     console.log(`\x1B[36mwould remove\x1B[0m  ${relative2}`);
   },
   error: (message) => {
@@ -138,6 +143,62 @@ var log = {
     console.log(message);
   }
 };
+
+// src/lib/strings.ts
+function toPascalCase(str) {
+  return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function toKebabCase(str) {
+  return toSnakeCase(str).replace(/_/g, "-");
+}
+function pluralize(str) {
+  if (str.endsWith("y") && !/[aeiou]y$/.test(str)) {
+    return str.slice(0, -1) + "ies";
+  }
+  if (str.endsWith("s") || str.endsWith("x") || str.endsWith("ch") || str.endsWith("sh")) {
+    return str + "es";
+  }
+  return str + "s";
+}
+function singularize(str) {
+  if (str.endsWith("ies")) {
+    return str.slice(0, -3) + "y";
+  }
+  if (str.endsWith("es") && (str.endsWith("xes") || str.endsWith("ches") || str.endsWith("shes") || str.endsWith("sses"))) {
+    return str.slice(0, -2);
+  }
+  if (str.endsWith("s") && !str.endsWith("ss")) {
+    return str.slice(0, -1);
+  }
+  return str;
+}
+function createModelContext(name) {
+  const singularName = singularize(name);
+  const pluralName = pluralize(singularName);
+  return {
+    name,
+    singularName,
+    pluralName,
+    pascalName: toPascalCase(singularName),
+    pascalPlural: toPascalCase(pluralName),
+    camelName: toCamelCase(singularName),
+    camelPlural: toCamelCase(pluralName),
+    snakeName: toSnakeCase(singularName),
+    snakePlural: toSnakeCase(pluralName),
+    kebabName: toKebabCase(singularName),
+    kebabPlural: toKebabCase(pluralName),
+    tableName: pluralize(toSnakeCase(singularName))
+  };
+}
+
+// src/lib/validation.ts
 function validateModelName(name) {
   if (!name) {
     throw new Error("Model name is required");
@@ -186,6 +247,8 @@ function validateFieldDefinition(fieldDef) {
     }
   }
 }
+
+// src/lib/parsing.ts
 function parseFields(fields) {
   return fields.map((field) => {
     validateFieldDefinition(field);
@@ -226,58 +289,8 @@ function parseFields(fields) {
     return { name, type, isReference: false, isEnum: false, nullable, unique };
   });
 }
-function toPascalCase(str) {
-  return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
-}
-function toCamelCase(str) {
-  const pascal = toPascalCase(str);
-  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
-}
-function toSnakeCase(str) {
-  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
-}
-function toKebabCase(str) {
-  return toSnakeCase(str).replace(/_/g, "-");
-}
-function pluralize(str) {
-  if (str.endsWith("y") && !/[aeiou]y$/.test(str)) {
-    return str.slice(0, -1) + "ies";
-  }
-  if (str.endsWith("s") || str.endsWith("x") || str.endsWith("ch") || str.endsWith("sh")) {
-    return str + "es";
-  }
-  return str + "s";
-}
-function singularize(str) {
-  if (str.endsWith("ies")) {
-    return str.slice(0, -3) + "y";
-  }
-  if (str.endsWith("es") && (str.endsWith("xes") || str.endsWith("ches") || str.endsWith("shes") || str.endsWith("sses"))) {
-    return str.slice(0, -2);
-  }
-  if (str.endsWith("s") && !str.endsWith("ss")) {
-    return str.slice(0, -1);
-  }
-  return str;
-}
-function createModelContext(name) {
-  const singularName = singularize(name);
-  const pluralName = pluralize(singularName);
-  return {
-    name,
-    singularName,
-    pluralName,
-    pascalName: toPascalCase(singularName),
-    pascalPlural: toPascalCase(pluralName),
-    camelName: toCamelCase(singularName),
-    camelPlural: toCamelCase(pluralName),
-    snakeName: toSnakeCase(singularName),
-    snakePlural: toSnakeCase(pluralName),
-    kebabName: toKebabCase(singularName),
-    kebabPlural: toKebabCase(pluralName),
-    tableName: pluralize(toSnakeCase(singularName))
-  };
-}
+
+// src/lib/drizzle.ts
 var SQLITE_TYPE_MAP = {
   string: "text",
   text: "text",
@@ -449,8 +462,12 @@ function getRequiredImports(fields, dialect, options = {}) {
   }
   return Array.from(types);
 }
+
+// src/lib/files.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
 function writeFile(filePath, content, options = {}) {
-  const exists = fs.existsSync(filePath);
+  const exists = fs2.existsSync(filePath);
   if (exists && !options.force) {
     log.skip(filePath);
     return false;
@@ -463,11 +480,11 @@ function writeFile(filePath, content, options = {}) {
     }
     return true;
   }
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
+  const dir = path3.dirname(filePath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
   }
-  fs.writeFileSync(filePath, content);
+  fs2.writeFileSync(filePath, content);
   if (exists && options.force) {
     log.force(filePath);
   } else {
@@ -476,7 +493,7 @@ function writeFile(filePath, content, options = {}) {
   return true;
 }
 function deleteDirectory(dirPath, options = {}) {
-  if (!fs.existsSync(dirPath)) {
+  if (!fs2.existsSync(dirPath)) {
     log.notFound(dirPath);
     return false;
   }
@@ -484,23 +501,25 @@ function deleteDirectory(dirPath, options = {}) {
     log.wouldRemove(dirPath);
     return true;
   }
-  fs.rmSync(dirPath, { recursive: true });
+  fs2.rmSync(dirPath, { recursive: true });
   log.remove(dirPath);
   return true;
 }
 function fileExists(filePath) {
-  return fs.existsSync(filePath);
+  return fs2.existsSync(filePath);
 }
 function readFile(filePath) {
-  return fs.readFileSync(filePath, "utf-8");
+  return fs2.readFileSync(filePath, "utf-8");
 }
 function modelExistsInSchema(tableName) {
-  const schemaPath = path.join(process.cwd(), "db", "schema.ts");
-  if (!fs.existsSync(schemaPath)) {
+  const schemaPath = path3.join(getDbPath(), "schema.ts");
+  if (!fs2.existsSync(schemaPath)) {
     return false;
   }
-  const content = fs.readFileSync(schemaPath, "utf-8");
-  const pattern = new RegExp(`sqliteTable\\s*\\(\\s*["']${tableName}["']`);
+  const content = fs2.readFileSync(schemaPath, "utf-8");
+  const pattern = new RegExp(
+    `(?:sqliteTable|pgTable|mysqlTable)\\s*\\(\\s*["']${tableName}["']`
+  );
   return pattern.test(content);
 }
 
@@ -515,7 +534,7 @@ function generateModel(name, fieldArgs, options = {}) {
       `Model "${ctx.pascalName}" already exists in schema. Use --force to regenerate.`
     );
   }
-  const schemaPath = path2.join(getDbPath(), "schema.ts");
+  const schemaPath = path4.join(getDbPath(), "schema.ts");
   if (fileExists(schemaPath) && !modelExistsInSchema(ctx.tableName)) {
     appendToSchema(schemaPath, ctx.camelPlural, ctx.tableName, fields, dialect, options);
   } else if (!fileExists(schemaPath)) {
@@ -625,22 +644,23 @@ function appendToSchema(schemaPath, modelName, tableName, fields, dialect, optio
 }
 
 // src/generators/actions.ts
-import * as path3 from "path";
+import * as path5 from "path";
 function generateActions(name, options = {}) {
   validateModelName(name);
   const ctx = createModelContext(name);
-  const actionsPath = path3.join(
+  const actionsPath = path5.join(
     getAppPath(),
     ctx.kebabPlural,
     "actions.ts"
   );
-  const content = generateActionsContent(ctx);
+  const content = generateActionsContent(ctx, options);
   writeFile(actionsPath, content, options);
 }
-function generateActionsContent(ctx) {
+function generateActionsContent(ctx, options = {}) {
   const { pascalName, pascalPlural, camelPlural, kebabPlural } = ctx;
   const dbImport = getDbImport();
   const schemaImport = getSchemaImport();
+  const idType = options.uuid ? "string" : "number";
   return `"use server";
 
 import { db } from "${dbImport}";
@@ -655,7 +675,7 @@ export async function get${pascalPlural}() {
   return db.select().from(${camelPlural}).orderBy(desc(${camelPlural}.createdAt));
 }
 
-export async function get${pascalName}(id: number) {
+export async function get${pascalName}(id: ${idType}) {
   const result = await db
     .select()
     .from(${camelPlural})
@@ -671,7 +691,7 @@ export async function create${pascalName}(data: Omit<New${pascalName}, "id" | "c
 }
 
 export async function update${pascalName}(
-  id: number,
+  id: ${idType},
   data: Partial<Omit<New${pascalName}, "id" | "createdAt" | "updatedAt">>
 ) {
   const result = await db
@@ -683,7 +703,7 @@ export async function update${pascalName}(
   return result[0];
 }
 
-export async function delete${pascalName}(id: number) {
+export async function delete${pascalName}(id: ${idType}) {
   await db.delete(${camelPlural}).where(eq(${camelPlural}.id, id));
   revalidatePath("/${kebabPlural}");
 }
@@ -691,7 +711,7 @@ export async function delete${pascalName}(id: number) {
 }
 
 // src/generators/scaffold.ts
-import * as path4 from "path";
+import * as path6 from "path";
 function generateScaffold(name, fieldArgs, options = {}) {
   validateModelName(name);
   const ctx = createModelContext(name);
@@ -710,25 +730,25 @@ Next steps:`);
 }
 function generatePages(ctx, fields, options = {}) {
   const { pascalName, pascalPlural, camelName, kebabPlural } = ctx;
-  const basePath = path4.join(getAppPath(), kebabPlural);
+  const basePath = path6.join(getAppPath(), kebabPlural);
   writeFile(
-    path4.join(basePath, "page.tsx"),
+    path6.join(basePath, "page.tsx"),
     generateIndexPage(pascalName, pascalPlural, camelName, kebabPlural, fields),
     options
   );
   writeFile(
-    path4.join(basePath, "new", "page.tsx"),
+    path6.join(basePath, "new", "page.tsx"),
     generateNewPage(pascalName, camelName, kebabPlural, fields),
     options
   );
   writeFile(
-    path4.join(basePath, "[id]", "page.tsx"),
-    generateShowPage(pascalName, pascalPlural, camelName, kebabPlural, fields),
+    path6.join(basePath, "[id]", "page.tsx"),
+    generateShowPage(pascalName, pascalPlural, camelName, kebabPlural, fields, options),
     options
   );
   writeFile(
-    path4.join(basePath, "[id]", "edit", "page.tsx"),
-    generateEditPage(pascalName, camelName, kebabPlural, fields),
+    path6.join(basePath, "[id]", "edit", "page.tsx"),
+    generateEditPage(pascalName, camelName, kebabPlural, fields, options),
     options
   );
 }
@@ -833,7 +853,12 @@ ${fields.map((f) => generateFormField(f, camelName)).join("\n\n")}
 }
 `;
 }
-function generateShowPage(pascalName, _pascalPlural, camelName, kebabPlural, fields) {
+function generateShowPage(pascalName, _pascalPlural, camelName, kebabPlural, fields, options = {}) {
+  const idHandling = options.uuid ? `const ${camelName} = await get${pascalName}(id);` : `const numericId = Number(id);
+  if (isNaN(numericId)) {
+    notFound();
+  }
+  const ${camelName} = await get${pascalName}(numericId);`;
   return `import { notFound } from "next/navigation";
 import Link from "next/link";
 import { get${pascalName} } from "../actions";
@@ -844,7 +869,7 @@ export default async function ${pascalName}Page({
   params: Promise<{ id: string }>;
 }) {
   const { id } = await params;
-  const ${camelName} = await get${pascalName}(parseInt(id));
+  ${idHandling}
 
   if (!${camelName}) {
     notFound();
@@ -887,7 +912,13 @@ ${fields.map(
 }
 `;
 }
-function generateEditPage(pascalName, camelName, kebabPlural, fields) {
+function generateEditPage(pascalName, camelName, kebabPlural, fields, options = {}) {
+  const idHandling = options.uuid ? `const ${camelName} = await get${pascalName}(id);` : `const numericId = Number(id);
+  if (isNaN(numericId)) {
+    notFound();
+  }
+  const ${camelName} = await get${pascalName}(numericId);`;
+  const updateId = options.uuid ? "id" : "numericId";
   return `import { notFound, redirect } from "next/navigation";
 import Link from "next/link";
 import { get${pascalName}, update${pascalName} } from "../../actions";
@@ -898,7 +929,7 @@ export default async function Edit${pascalName}Page({
   params: Promise<{ id: string }>;
 }) {
   const { id } = await params;
-  const ${camelName} = await get${pascalName}(parseInt(id));
+  ${idHandling}
 
   if (!${camelName}) {
     notFound();
@@ -906,7 +937,7 @@ export default async function Edit${pascalName}Page({
 
   async function handleUpdate(formData: FormData) {
     "use server";
-    await update${pascalName}(parseInt(id), {
+    await update${pascalName}(${updateId}, {
 ${fields.map((f) => `      ${f.name}: ${formDataValue(f)},`).join("\n")}
     });
     redirect("/${kebabPlural}");
@@ -1114,7 +1145,7 @@ Next steps:`);
 }
 
 // src/generators/api.ts
-import * as path5 from "path";
+import * as path7 from "path";
 function generateApi(name, fieldArgs, options = {}) {
   validateModelName(name);
   const ctx = createModelContext(name);
@@ -1130,19 +1161,19 @@ Next steps:`);
   log.info(`  2. API available at /api/${ctx.kebabPlural}`);
 }
 function generateRoutes(camelPlural, kebabPlural, options) {
-  const basePath = path5.join(getAppPath(), "api", kebabPlural);
+  const basePath = path7.join(getAppPath(), "api", kebabPlural);
   writeFile(
-    path5.join(basePath, "route.ts"),
-    generateCollectionRoute(camelPlural),
+    path7.join(basePath, "route.ts"),
+    generateCollectionRoute(camelPlural, kebabPlural),
     options
   );
   writeFile(
-    path5.join(basePath, "[id]", "route.ts"),
-    generateMemberRoute(camelPlural),
+    path7.join(basePath, "[id]", "route.ts"),
+    generateMemberRoute(camelPlural, kebabPlural, options),
     options
   );
 }
-function generateCollectionRoute(camelPlural) {
+function generateCollectionRoute(camelPlural, kebabPlural) {
   const dbImport = getDbImport();
   const schemaImport = getSchemaImport();
   return `import { db } from "${dbImport}";
@@ -1158,7 +1189,8 @@ export async function GET() {
       .orderBy(desc(${camelPlural}.createdAt));
 
     return NextResponse.json(data);
-  } catch {
+  } catch (error) {
+    console.error("GET /api/${kebabPlural} failed:", error);
     return NextResponse.json(
       { error: "Failed to fetch records" },
       { status: 500 }
@@ -1172,7 +1204,14 @@ export async function POST(request: Request) {
     const result = await db.insert(${camelPlural}).values(body).returning();
 
     return NextResponse.json(result[0], { status: 201 });
-  } catch {
+  } catch (error) {
+    console.error("POST /api/${kebabPlural} failed:", error);
+    if (error instanceof SyntaxError) {
+      return NextResponse.json(
+        { error: "Invalid JSON in request body" },
+        { status: 400 }
+      );
+    }
     return NextResponse.json(
       { error: "Failed to create record" },
       { status: 500 }
@@ -1181,9 +1220,18 @@ export async function POST(request: Request) {
 }
 `;
 }
-function generateMemberRoute(camelPlural) {
+function generateMemberRoute(camelPlural, kebabPlural, options = {}) {
   const dbImport = getDbImport();
   const schemaImport = getSchemaImport();
+  const idValidation = options.uuid ? "" : `
+    const numericId = Number(id);
+    if (isNaN(numericId)) {
+      return NextResponse.json(
+        { error: "Invalid ID format" },
+        { status: 400 }
+      );
+    }`;
+  const idValue = options.uuid ? "id" : "numericId";
   return `import { db } from "${dbImport}";
 import { ${camelPlural} } from "${schemaImport}";
 import { eq } from "drizzle-orm";
@@ -1193,11 +1241,11 @@ type Params = { params: Promise<{ id: string }> };
 
 export async function GET(request: Request, { params }: Params) {
   try {
-    const { id } = await params;
+    const { id } = await params;${idValidation}
     const result = await db
       .select()
       .from(${camelPlural})
-      .where(eq(${camelPlural}.id, parseInt(id)))
+      .where(eq(${camelPlural}.id, ${idValue}))
       .limit(1);
 
     if (!result[0]) {
@@ -1208,7 +1256,8 @@ export async function GET(request: Request, { params }: Params) {
     }
 
     return NextResponse.json(result[0]);
-  } catch {
+  } catch (error) {
+    console.error("GET /api/${kebabPlural}/[id] failed:", error);
     return NextResponse.json(
       { error: "Failed to fetch record" },
       { status: 500 }
@@ -1218,12 +1267,12 @@ export async function GET(request: Request, { params }: Params) {
 
 export async function PATCH(request: Request, { params }: Params) {
   try {
-    const { id } = await params;
+    const { id } = await params;${idValidation}
     const body = await request.json();
     const result = await db
       .update(${camelPlural})
       .set({ ...body, updatedAt: new Date() })
-      .where(eq(${camelPlural}.id, parseInt(id)))
+      .where(eq(${camelPlural}.id, ${idValue}))
       .returning();
 
     if (!result[0]) {
@@ -1234,7 +1283,14 @@ export async function PATCH(request: Request, { params }: Params) {
     }
 
     return NextResponse.json(result[0]);
-  } catch {
+  } catch (error) {
+    console.error("PATCH /api/${kebabPlural}/[id] failed:", error);
+    if (error instanceof SyntaxError) {
+      return NextResponse.json(
+        { error: "Invalid JSON in request body" },
+        { status: 400 }
+      );
+    }
     return NextResponse.json(
       { error: "Failed to update record" },
       { status: 500 }
@@ -1244,11 +1300,12 @@ export async function PATCH(request: Request, { params }: Params) {
 
 export async function DELETE(request: Request, { params }: Params) {
   try {
-    const { id } = await params;
-    await db.delete(${camelPlural}).where(eq(${camelPlural}.id, parseInt(id)));
+    const { id } = await params;${idValidation}
+    await db.delete(${camelPlural}).where(eq(${camelPlural}.id, ${idValue}));
 
     return new NextResponse(null, { status: 204 });
-  } catch {
+  } catch (error) {
+    console.error("DELETE /api/${kebabPlural}/[id] failed:", error);
     return NextResponse.json(
       { error: "Failed to delete record" },
       { status: 500 }
@@ -1259,7 +1316,7 @@ export async function DELETE(request: Request, { params }: Params) {
 }
 
 // src/generators/destroy.ts
-import * as path6 from "path";
+import * as path8 from "path";
 function destroyScaffold(name, options = {}) {
   validateModelName(name);
   const ctx = createModelContext(name);
@@ -1268,7 +1325,7 @@ function destroyScaffold(name, options = {}) {
   log.info(`
 ${prefix}Destroying scaffold ${ctx.pascalName}...
 `);
-  const basePath = path6.join(getAppPath(), ctx.kebabPlural);
+  const basePath = path8.join(getAppPath(), ctx.kebabPlural);
   deleteDirectory(basePath, options);
   log.info(`
 Note: Schema in ${config.dbPath}/schema.ts was not modified.`);
@@ -1282,7 +1339,7 @@ function destroyResource(name, options = {}) {
   log.info(`
 ${prefix}Destroying resource ${ctx.pascalName}...
 `);
-  const basePath = path6.join(getAppPath(), ctx.kebabPlural);
+  const basePath = path8.join(getAppPath(), ctx.kebabPlural);
   deleteDirectory(basePath, options);
   log.info(`
 Note: Schema in ${config.dbPath}/schema.ts was not modified.`);
@@ -1296,7 +1353,7 @@ function destroyApi(name, options = {}) {
   log.info(`
 ${prefix}Destroying API ${ctx.pascalName}...
 `);
-  const basePath = path6.join(getAppPath(), "api", ctx.kebabPlural);
+  const basePath = path8.join(getAppPath(), "api", ctx.kebabPlural);
   deleteDirectory(basePath, options);
   log.info(`
 Note: Schema in ${config.dbPath}/schema.ts was not modified.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nextjs-drizzle-gen",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Rails-like generators for Next.js + Drizzle ORM projects",
   "type": "module",
   "bin": {