nextjs-drizzle-gen 0.1.0

package/dist/index.js

@@ -0,0 +1,1437 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+
+// src/generators/model.ts
+import * as path2 from "path";
+
+// src/utils.ts
+import * as fs from "fs";
+import * as path from "path";
+var VALID_FIELD_TYPES = [
+  "string",
+  "text",
+  "integer",
+  "int",
+  "bigint",
+  "boolean",
+  "bool",
+  "datetime",
+  "timestamp",
+  "date",
+  "float",
+  "decimal",
+  "json",
+  "uuid"
+];
+function detectDialect() {
+  const configPath = path.join(process.cwd(), "drizzle.config.ts");
+  if (!fs.existsSync(configPath)) {
+    return "sqlite";
+  }
+  const content = fs.readFileSync(configPath, "utf-8");
+  const match = content.match(/dialect:\s*["'](\w+)["']/);
+  if (match) {
+    const dialect = match[1];
+    if (["postgresql", "postgres", "pg"].includes(dialect)) {
+      return "postgresql";
+    }
+    if (["mysql", "mysql2"].includes(dialect)) {
+      return "mysql";
+    }
+  }
+  return "sqlite";
+}
+var cachedProjectConfig = null;
+function detectProjectConfig() {
+  if (cachedProjectConfig) {
+    return cachedProjectConfig;
+  }
+  const cwd = process.cwd();
+  const useSrc = fs.existsSync(path.join(cwd, "src", "app"));
+  let alias = "@";
+  const tsconfigPath = path.join(cwd, "tsconfig.json");
+  if (fs.existsSync(tsconfigPath)) {
+    try {
+      const content = fs.readFileSync(tsconfigPath, "utf-8");
+      const cleanContent = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+      const tsconfig = JSON.parse(cleanContent);
+      const paths = tsconfig?.compilerOptions?.paths;
+      if (paths) {
+        for (const key of Object.keys(paths)) {
+          const match = key.match(/^(@\w*|~)\//);
+          if (match) {
+            alias = match[1];
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  let dbPath = useSrc ? "src/db" : "db";
+  const possibleDbPaths = useSrc ? ["src/db", "src/lib/db", "src/server/db"] : ["db", "lib/db", "server/db"];
+  for (const possiblePath of possibleDbPaths) {
+    if (fs.existsSync(path.join(cwd, possiblePath))) {
+      dbPath = possiblePath;
+      break;
+    }
+  }
+  const appPath = useSrc ? "src/app" : "app";
+  cachedProjectConfig = { useSrc, alias, dbPath, appPath };
+  return cachedProjectConfig;
+}
+function getDbImport() {
+  const config = detectProjectConfig();
+  const importPath = config.dbPath.replace(/^src\//, "");
+  return `${config.alias}/${importPath}`;
+}
+function getSchemaImport() {
+  return `${getDbImport()}/schema`;
+}
+function getAppPath() {
+  const config = detectProjectConfig();
+  return path.join(process.cwd(), config.appPath);
+}
+function getDbPath() {
+  const config = detectProjectConfig();
+  return path.join(process.cwd(), config.dbPath);
+}
+var log = {
+  create: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`      \x1B[32mcreate\x1B[0m  ${relative2}`);
+  },
+  force: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`       \x1B[33mforce\x1B[0m  ${relative2}`);
+  },
+  skip: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`        \x1B[33mskip\x1B[0m  ${relative2}`);
+  },
+  remove: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`      \x1B[31mremove\x1B[0m  ${relative2}`);
+  },
+  notFound: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`   \x1B[33mnot found\x1B[0m  ${relative2}`);
+  },
+  wouldCreate: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`\x1B[36mwould create\x1B[0m  ${relative2}`);
+  },
+  wouldForce: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(` \x1B[36mwould force\x1B[0m  ${relative2}`);
+  },
+  wouldRemove: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`\x1B[36mwould remove\x1B[0m  ${relative2}`);
+  },
+  error: (message) => {
+    console.error(`\x1B[31mError:\x1B[0m ${message}`);
+  },
+  info: (message) => {
+    console.log(message);
+  }
+};
+function validateModelName(name) {
+  if (!name) {
+    throw new Error("Model name is required");
+  }
+  if (!/^[A-Za-z][A-Za-z0-9]*$/.test(name)) {
+    throw new Error(
+      `Invalid model name "${name}". Must start with a letter and contain only letters and numbers.`
+    );
+  }
+  const reserved = ["model", "schema", "db", "database", "table"];
+  if (reserved.includes(name.toLowerCase())) {
+    throw new Error(`"${name}" is a reserved word and cannot be used as a model name.`);
+  }
+}
+function validateFieldDefinition(fieldDef) {
+  const parts = fieldDef.split(":");
+  let name = parts[0];
+  let type = parts[1] || "string";
+  if (name.endsWith("?")) {
+    name = name.slice(0, -1);
+  }
+  if (type.endsWith("?")) {
+    type = type.slice(0, -1);
+  }
+  if (!name) {
+    throw new Error(`Invalid field definition "${fieldDef}". Field name is required.`);
+  }
+  if (!/^[a-z][a-zA-Z0-9]*$/.test(name)) {
+    throw new Error(
+      `Invalid field name "${name}". Must be camelCase (start with lowercase letter).`
+    );
+  }
+  if (type && !type.startsWith("references") && type !== "enum" && type !== "unique") {
+    if (!VALID_FIELD_TYPES.includes(type)) {
+      throw new Error(
+        `Invalid field type "${type}". Valid types: ${VALID_FIELD_TYPES.join(", ")}, enum`
+      );
+    }
+  }
+  if (type === "enum") {
+    const enumValues = parts[2];
+    if (!enumValues || enumValues === "unique") {
+      throw new Error(
+        `Enum field "${name}" requires values. Example: ${name}:enum:draft,published,archived`
+      );
+    }
+  }
+}
+function parseFields(fields) {
+  return fields.map((field) => {
+    validateFieldDefinition(field);
+    const parts = field.split(":");
+    let name = parts[0];
+    let type = parts[1] || "string";
+    const nullable = name.endsWith("?") || type.endsWith("?");
+    if (name.endsWith("?")) {
+      name = name.slice(0, -1);
+    }
+    if (type.endsWith("?")) {
+      type = type.slice(0, -1);
+    }
+    const unique = parts.includes("unique");
+    if (type === "references") {
+      return {
+        name,
+        type: "integer",
+        isReference: true,
+        referenceTo: parts[2],
+        isEnum: false,
+        nullable,
+        unique
+      };
+    }
+    if (type === "enum") {
+      const enumValues = parts[2]?.split(",") || [];
+      return {
+        name,
+        type: "enum",
+        isReference: false,
+        isEnum: true,
+        enumValues,
+        nullable,
+        unique
+      };
+    }
+    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))
+  };
+}
+var SQLITE_TYPE_MAP = {
+  string: "text",
+  text: "text",
+  integer: "integer",
+  int: "integer",
+  bigint: "integer",
+  // SQLite doesn't distinguish
+  boolean: 'integer({ mode: "boolean" })',
+  bool: 'integer({ mode: "boolean" })',
+  datetime: 'integer({ mode: "timestamp" })',
+  timestamp: 'integer({ mode: "timestamp" })',
+  date: 'integer({ mode: "timestamp" })',
+  float: "real",
+  decimal: "text",
+  // SQLite has no native decimal
+  json: "text",
+  // Store as JSON string
+  uuid: "text"
+  // Store as text
+};
+var POSTGRESQL_TYPE_MAP = {
+  string: "text",
+  text: "text",
+  integer: "integer",
+  int: "integer",
+  bigint: "bigint",
+  boolean: "boolean",
+  bool: "boolean",
+  datetime: "timestamp",
+  timestamp: "timestamp",
+  date: "date",
+  float: "doublePrecision",
+  decimal: "numeric",
+  json: "jsonb",
+  uuid: "uuid"
+};
+var MYSQL_TYPE_MAP = {
+  string: "varchar",
+  text: "text",
+  integer: "int",
+  int: "int",
+  bigint: "bigint",
+  boolean: "boolean",
+  bool: "boolean",
+  datetime: "datetime",
+  timestamp: "timestamp",
+  date: "date",
+  float: "double",
+  decimal: "decimal",
+  json: "json",
+  uuid: "varchar"
+  // Store as varchar(36)
+};
+function drizzleType(field, dialect = "sqlite") {
+  const typeMap = dialect === "postgresql" ? POSTGRESQL_TYPE_MAP : dialect === "mysql" ? MYSQL_TYPE_MAP : SQLITE_TYPE_MAP;
+  return typeMap[field.type] || "text";
+}
+function getDrizzleImport(dialect) {
+  switch (dialect) {
+    case "postgresql":
+      return "drizzle-orm/pg-core";
+    case "mysql":
+      return "drizzle-orm/mysql-core";
+    default:
+      return "drizzle-orm/sqlite-core";
+  }
+}
+function getTableFunction(dialect) {
+  switch (dialect) {
+    case "postgresql":
+      return "pgTable";
+    case "mysql":
+      return "mysqlTable";
+    default:
+      return "sqliteTable";
+  }
+}
+function getIdColumn(dialect, useUuid = false) {
+  if (useUuid) {
+    switch (dialect) {
+      case "postgresql":
+        return 'id: uuid("id").primaryKey().defaultRandom()';
+      case "mysql":
+        return 'id: varchar("id", { length: 36 }).primaryKey().$defaultFn(() => crypto.randomUUID())';
+      default:
+        return 'id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID())';
+    }
+  }
+  switch (dialect) {
+    case "postgresql":
+      return 'id: serial("id").primaryKey()';
+    case "mysql":
+      return 'id: int("id").primaryKey().autoincrement()';
+    default:
+      return 'id: integer("id").primaryKey({ autoIncrement: true })';
+  }
+}
+function getTimestampColumns(dialect, noTimestamps = false) {
+  if (noTimestamps) {
+    return null;
+  }
+  switch (dialect) {
+    case "postgresql":
+      return `createdAt: timestamp("created_at")
+    .notNull()
+    .defaultNow(),
+  updatedAt: timestamp("updated_at")
+    .notNull()
+    .defaultNow()`;
+    case "mysql":
+      return `createdAt: datetime("created_at")
+    .notNull()
+    .$defaultFn(() => new Date()),
+  updatedAt: datetime("updated_at")
+    .notNull()
+    .$defaultFn(() => new Date())`;
+    default:
+      return `createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .$defaultFn(() => new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .$defaultFn(() => new Date())`;
+  }
+}
+function getRequiredImports(fields, dialect, options = {}) {
+  const types = /* @__PURE__ */ new Set();
+  types.add(getTableFunction(dialect));
+  if (options.uuid) {
+    if (dialect === "postgresql") {
+      types.add("uuid");
+    } else if (dialect === "mysql") {
+      types.add("varchar");
+    } else {
+      types.add("text");
+    }
+  } else {
+    if (dialect === "postgresql") {
+      types.add("serial");
+    } else if (dialect === "mysql") {
+      types.add("int");
+    } else {
+      types.add("integer");
+    }
+  }
+  if (!options.noTimestamps) {
+    if (dialect === "postgresql") {
+      types.add("timestamp");
+    } else if (dialect === "mysql") {
+      types.add("datetime");
+    }
+  }
+  const hasEnums = fields.some((f) => f.isEnum);
+  if (hasEnums) {
+    if (dialect === "postgresql") {
+      types.add("pgEnum");
+    } else if (dialect === "mysql") {
+      types.add("mysqlEnum");
+    }
+  }
+  for (const field of fields) {
+    if (field.isEnum) continue;
+    const drizzleTypeDef = drizzleType(field, dialect);
+    const baseType = drizzleTypeDef.split("(")[0];
+    types.add(baseType);
+  }
+  if (dialect !== "mysql") {
+    types.add("text");
+  }
+  return Array.from(types);
+}
+function writeFile(filePath, content, options = {}) {
+  const exists = fs.existsSync(filePath);
+  if (exists && !options.force) {
+    log.skip(filePath);
+    return false;
+  }
+  if (options.dryRun) {
+    if (exists && options.force) {
+      log.wouldForce(filePath);
+    } else {
+      log.wouldCreate(filePath);
+    }
+    return true;
+  }
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, content);
+  if (exists && options.force) {
+    log.force(filePath);
+  } else {
+    log.create(filePath);
+  }
+  return true;
+}
+function deleteDirectory(dirPath, options = {}) {
+  if (!fs.existsSync(dirPath)) {
+    log.notFound(dirPath);
+    return false;
+  }
+  if (options.dryRun) {
+    log.wouldRemove(dirPath);
+    return true;
+  }
+  fs.rmSync(dirPath, { recursive: true });
+  log.remove(dirPath);
+  return true;
+}
+function fileExists(filePath) {
+  return fs.existsSync(filePath);
+}
+function readFile(filePath) {
+  return fs.readFileSync(filePath, "utf-8");
+}
+function modelExistsInSchema(tableName) {
+  const schemaPath = path.join(process.cwd(), "db", "schema.ts");
+  if (!fs.existsSync(schemaPath)) {
+    return false;
+  }
+  const content = fs.readFileSync(schemaPath, "utf-8");
+  const pattern = new RegExp(`sqliteTable\\s*\\(\\s*["']${tableName}["']`);
+  return pattern.test(content);
+}
+
+// src/generators/model.ts
+function generateModel(name, fieldArgs, options = {}) {
+  validateModelName(name);
+  const ctx = createModelContext(name);
+  const fields = parseFields(fieldArgs);
+  const dialect = detectDialect();
+  if (modelExistsInSchema(ctx.tableName) && !options.force) {
+    throw new Error(
+      `Model "${ctx.pascalName}" already exists in schema. Use --force to regenerate.`
+    );
+  }
+  const schemaPath = path2.join(getDbPath(), "schema.ts");
+  if (fileExists(schemaPath) && !modelExistsInSchema(ctx.tableName)) {
+    appendToSchema(schemaPath, ctx.camelPlural, ctx.tableName, fields, dialect, options);
+  } else if (!fileExists(schemaPath)) {
+    const schemaContent = generateSchemaContent(ctx.camelPlural, ctx.tableName, fields, dialect, options);
+    writeFile(schemaPath, schemaContent, options);
+  } else {
+    throw new Error(
+      `Cannot regenerate model "${ctx.pascalName}" - manual removal from schema required.`
+    );
+  }
+}
+function generateSchemaContent(modelName, tableName, fields, dialect, options = {}) {
+  const imports = getRequiredImports(fields, dialect, options);
+  const drizzleImport = getDrizzleImport(dialect);
+  const enumDefinitions = generateEnumDefinitions(fields, dialect);
+  const tableDefinition = generateTableDefinition(modelName, tableName, fields, dialect, options);
+  return `import { ${imports.join(", ")} } from "${drizzleImport}";
+${enumDefinitions}
+${tableDefinition}
+`;
+}
+function generateEnumDefinitions(fields, dialect) {
+  if (dialect !== "postgresql") {
+    return "";
+  }
+  const enumFields = fields.filter((f) => f.isEnum && f.enumValues);
+  if (enumFields.length === 0) {
+    return "";
+  }
+  return enumFields.map((field) => {
+    const enumName = `${field.name}Enum`;
+    const values = field.enumValues.map((v) => `"${v}"`).join(", ");
+    return `
+export const ${enumName} = pgEnum("${toSnakeCase(field.name)}", [${values}]);`;
+  }).join("\n");
+}
+function generateTableDefinition(modelName, tableName, fields, dialect, options = {}) {
+  const tableFunction = getTableFunction(dialect);
+  const idColumn = getIdColumn(dialect, options.uuid);
+  const timestampColumns = getTimestampColumns(dialect, options.noTimestamps);
+  const fieldDefinitions = generateFieldDefinitions(fields, dialect);
+  const lines = [`  ${idColumn},`];
+  if (fieldDefinitions) {
+    lines.push(fieldDefinitions);
+  }
+  if (timestampColumns) {
+    lines.push(`  ${timestampColumns},`);
+  }
+  return `export const ${modelName} = ${tableFunction}("${tableName}", {
+${lines.join("\n")}
+});`;
+}
+function generateFieldDefinitions(fields, dialect) {
+  return fields.map((field) => {
+    const columnName = toSnakeCase(field.name);
+    const modifiers = getFieldModifiers(field);
+    if (field.isEnum && field.enumValues) {
+      return generateEnumField(field, columnName, dialect);
+    }
+    const drizzleTypeDef = drizzleType(field, dialect);
+    if (field.isReference && field.referenceTo) {
+      const intType = dialect === "mysql" ? "int" : "integer";
+      return `  ${field.name}: ${intType}("${columnName}").references(() => ${toCamelCase(pluralize(field.referenceTo))}.id)${modifiers},`;
+    }
+    if (dialect === "mysql" && drizzleTypeDef === "varchar") {
+      const length = field.type === "uuid" ? 36 : 255;
+      return `  ${field.name}: varchar("${columnName}", { length: ${length} })${modifiers},`;
+    }
+    if (drizzleTypeDef.includes("(")) {
+      const [typeName] = drizzleTypeDef.split("(");
+      const typeOptions = drizzleTypeDef.match(/\(.*\)/)?.[0] ?? "";
+      return `  ${field.name}: ${typeName}("${columnName}", ${typeOptions})${modifiers},`;
+    }
+    return `  ${field.name}: ${drizzleTypeDef}("${columnName}")${modifiers},`;
+  }).join("\n");
+}
+function getFieldModifiers(field) {
+  const modifiers = [];
+  if (!field.nullable) {
+    modifiers.push(".notNull()");
+  }
+  if (field.unique) {
+    modifiers.push(".unique()");
+  }
+  return modifiers.join("");
+}
+function generateEnumField(field, columnName, dialect) {
+  const values = field.enumValues;
+  const modifiers = getFieldModifiers(field);
+  switch (dialect) {
+    case "postgresql":
+      return `  ${field.name}: ${field.name}Enum("${columnName}")${modifiers},`;
+    case "mysql":
+      const mysqlValues = values.map((v) => `"${v}"`).join(", ");
+      return `  ${field.name}: mysqlEnum("${columnName}", [${mysqlValues}])${modifiers},`;
+    default:
+      const sqliteValues = values.map((v) => `"${v}"`).join(", ");
+      return `  ${field.name}: text("${columnName}", { enum: [${sqliteValues}] })${modifiers},`;
+  }
+}
+function appendToSchema(schemaPath, modelName, tableName, fields, dialect, options) {
+  const existingContent = readFile(schemaPath);
+  const enumDefinitions = generateEnumDefinitions(fields, dialect);
+  const tableDefinition = generateTableDefinition(modelName, tableName, fields, dialect, options);
+  const newContent = existingContent + enumDefinitions + "\n" + tableDefinition + "\n";
+  writeFile(schemaPath, newContent, { force: true, dryRun: options.dryRun });
+}
+
+// src/generators/actions.ts
+import * as path3 from "path";
+function generateActions(name, options = {}) {
+  validateModelName(name);
+  const ctx = createModelContext(name);
+  const actionsPath = path3.join(
+    getAppPath(),
+    ctx.kebabPlural,
+    "actions.ts"
+  );
+  const content = generateActionsContent(ctx);
+  writeFile(actionsPath, content, options);
+}
+function generateActionsContent(ctx) {
+  const { pascalName, pascalPlural, camelPlural, kebabPlural } = ctx;
+  const dbImport = getDbImport();
+  const schemaImport = getSchemaImport();
+  return `"use server";
+
+import { db } from "${dbImport}";
+import { ${camelPlural} } from "${schemaImport}";
+import { eq, desc } from "drizzle-orm";
+import { revalidatePath } from "next/cache";
+
+export type ${pascalName} = typeof ${camelPlural}.$inferSelect;
+export type New${pascalName} = typeof ${camelPlural}.$inferInsert;
+
+export async function get${pascalPlural}() {
+  return db.select().from(${camelPlural}).orderBy(desc(${camelPlural}.createdAt));
+}
+
+export async function get${pascalName}(id: number) {
+  const result = await db
+    .select()
+    .from(${camelPlural})
+    .where(eq(${camelPlural}.id, id))
+    .limit(1);
+  return result[0] ?? null;
+}
+
+export async function create${pascalName}(data: Omit<New${pascalName}, "id" | "createdAt" | "updatedAt">) {
+  const result = await db.insert(${camelPlural}).values(data).returning();
+  revalidatePath("/${kebabPlural}");
+  return result[0];
+}
+
+export async function update${pascalName}(
+  id: number,
+  data: Partial<Omit<New${pascalName}, "id" | "createdAt" | "updatedAt">>
+) {
+  const result = await db
+    .update(${camelPlural})
+    .set({ ...data, updatedAt: new Date() })
+    .where(eq(${camelPlural}.id, id))
+    .returning();
+  revalidatePath("/${kebabPlural}");
+  return result[0];
+}
+
+export async function delete${pascalName}(id: number) {
+  await db.delete(${camelPlural}).where(eq(${camelPlural}.id, id));
+  revalidatePath("/${kebabPlural}");
+}
+`;
+}
+
+// src/generators/scaffold.ts
+import * as path4 from "path";
+function generateScaffold(name, fieldArgs, options = {}) {
+  validateModelName(name);
+  const ctx = createModelContext(name);
+  const fields = parseFields(fieldArgs);
+  const prefix = options.dryRun ? "[dry-run] " : "";
+  log.info(`
+${prefix}Scaffolding ${ctx.pascalName}...
+`);
+  generateModel(ctx.singularName, fieldArgs, options);
+  generateActions(ctx.singularName, options);
+  generatePages(ctx, fields, options);
+  log.info(`
+Next steps:`);
+  log.info(`  1. Run 'pnpm db:push' to update the database`);
+  log.info(`  2. Run 'pnpm dev' and visit /${ctx.kebabPlural}`);
+}
+function generatePages(ctx, fields, options = {}) {
+  const { pascalName, pascalPlural, camelName, kebabPlural } = ctx;
+  const basePath = path4.join(getAppPath(), kebabPlural);
+  writeFile(
+    path4.join(basePath, "page.tsx"),
+    generateIndexPage(pascalName, pascalPlural, camelName, kebabPlural, fields),
+    options
+  );
+  writeFile(
+    path4.join(basePath, "new", "page.tsx"),
+    generateNewPage(pascalName, camelName, kebabPlural, fields),
+    options
+  );
+  writeFile(
+    path4.join(basePath, "[id]", "page.tsx"),
+    generateShowPage(pascalName, pascalPlural, camelName, kebabPlural, fields),
+    options
+  );
+  writeFile(
+    path4.join(basePath, "[id]", "edit", "page.tsx"),
+    generateEditPage(pascalName, camelName, kebabPlural, fields),
+    options
+  );
+}
+function generateIndexPage(pascalName, pascalPlural, camelName, kebabPlural, fields) {
+  const displayField = fields[0]?.name || "id";
+  return `import Link from "next/link";
+import { get${pascalPlural} } from "./actions";
+import { delete${pascalName} } from "./actions";
+
+export default async function ${pascalPlural}Page() {
+  const ${camelName}s = await get${pascalPlural}();
+
+  return (
+    <div className="mx-auto max-w-3xl px-6 py-12">
+      <div className="mb-10 flex items-center justify-between">
+        <h1 className="text-2xl font-semibold text-gray-900">${pascalPlural}</h1>
+        <Link
+          href="/${kebabPlural}/new"
+          className="rounded-lg bg-gray-900 px-4 py-2 text-sm font-medium text-white transition-colors hover:bg-gray-800"
+        >
+          New ${pascalName}
+        </Link>
+      </div>
+
+      {${camelName}s.length === 0 ? (
+        <p className="text-gray-500">No ${camelName}s yet.</p>
+      ) : (
+        <div className="divide-y divide-gray-100">
+          {${camelName}s.map((${camelName}) => (
+            <div
+              key={${camelName}.id}
+              className="flex items-center justify-between py-4"
+            >
+              <Link href={\`/${kebabPlural}/\${${camelName}.id}\`} className="font-medium text-gray-900 hover:text-gray-600">
+                {${camelName}.${displayField}}
+              </Link>
+              <div className="flex gap-4 text-sm">
+                <Link
+                  href={\`/${kebabPlural}/\${${camelName}.id}/edit\`}
+                  className="text-gray-500 hover:text-gray-900"
+                >
+                  Edit
+                </Link>
+                <form
+                  action={async () => {
+                    "use server";
+                    await delete${pascalName}(${camelName}.id);
+                  }}
+                >
+                  <button type="submit" className="text-gray-500 hover:text-red-600">
+                    Delete
+                  </button>
+                </form>
+              </div>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
+`;
+}
+function generateNewPage(pascalName, camelName, kebabPlural, fields) {
+  return `import { redirect } from "next/navigation";
+import Link from "next/link";
+import { create${pascalName} } from "../actions";
+
+export default function New${pascalName}Page() {
+  async function handleCreate(formData: FormData) {
+    "use server";
+    await create${pascalName}({
+${fields.map((f) => `      ${f.name}: ${formDataValue(f)},`).join("\n")}
+    });
+    redirect("/${kebabPlural}");
+  }
+
+  return (
+    <div className="mx-auto max-w-xl px-6 py-12">
+      <h1 className="mb-8 text-2xl font-semibold text-gray-900">New ${pascalName}</h1>
+
+      <form action={handleCreate} className="space-y-5">
+${fields.map((f) => generateFormField(f, camelName)).join("\n\n")}
+
+        <div className="flex gap-3 pt-4">
+          <button
+            type="submit"
+            className="rounded-lg bg-gray-900 px-4 py-2 text-sm font-medium text-white transition-colors hover:bg-gray-800"
+          >
+            Create ${pascalName}
+          </button>
+          <Link
+            href="/${kebabPlural}"
+            className="rounded-lg border border-gray-200 px-4 py-2 text-sm font-medium text-gray-600 transition-colors hover:bg-gray-50"
+          >
+            Cancel
+          </Link>
+        </div>
+      </form>
+    </div>
+  );
+}
+`;
+}
+function generateShowPage(pascalName, _pascalPlural, camelName, kebabPlural, fields) {
+  return `import { notFound } from "next/navigation";
+import Link from "next/link";
+import { get${pascalName} } from "../actions";
+
+export default async function ${pascalName}Page({
+  params,
+}: {
+  params: Promise<{ id: string }>;
+}) {
+  const { id } = await params;
+  const ${camelName} = await get${pascalName}(parseInt(id));
+
+  if (!${camelName}) {
+    notFound();
+  }
+
+  return (
+    <div className="mx-auto max-w-xl px-6 py-12">
+      <div className="mb-8 flex items-center justify-between">
+        <h1 className="text-2xl font-semibold text-gray-900">${pascalName}</h1>
+        <div className="flex gap-3">
+          <Link
+            href={\`/${kebabPlural}/\${${camelName}.id}/edit\`}
+            className="rounded-lg bg-gray-900 px-4 py-2 text-sm font-medium text-white transition-colors hover:bg-gray-800"
+          >
+            Edit
+          </Link>
+          <Link
+            href="/${kebabPlural}"
+            className="rounded-lg border border-gray-200 px-4 py-2 text-sm font-medium text-gray-600 transition-colors hover:bg-gray-50"
+          >
+            Back
+          </Link>
+        </div>
+      </div>
+
+      <dl className="divide-y divide-gray-100">
+${fields.map(
+    (f) => `        <div className="py-3">
+          <dt className="text-sm text-gray-500">${toPascalCase(f.name)}</dt>
+          <dd className="mt-1 text-gray-900">{${camelName}.${f.name}}</dd>
+        </div>`
+  ).join("\n")}
+        <div className="py-3">
+          <dt className="text-sm text-gray-500">Created At</dt>
+          <dd className="mt-1 text-gray-900">{${camelName}.createdAt.toLocaleString()}</dd>
+        </div>
+      </dl>
+    </div>
+  );
+}
+`;
+}
+function generateEditPage(pascalName, camelName, kebabPlural, fields) {
+  return `import { notFound, redirect } from "next/navigation";
+import Link from "next/link";
+import { get${pascalName}, update${pascalName} } from "../../actions";
+
+export default async function Edit${pascalName}Page({
+  params,
+}: {
+  params: Promise<{ id: string }>;
+}) {
+  const { id } = await params;
+  const ${camelName} = await get${pascalName}(parseInt(id));
+
+  if (!${camelName}) {
+    notFound();
+  }
+
+  async function handleUpdate(formData: FormData) {
+    "use server";
+    await update${pascalName}(parseInt(id), {
+${fields.map((f) => `      ${f.name}: ${formDataValue(f)},`).join("\n")}
+    });
+    redirect("/${kebabPlural}");
+  }
+
+  return (
+    <div className="mx-auto max-w-xl px-6 py-12">
+      <h1 className="mb-8 text-2xl font-semibold text-gray-900">Edit ${pascalName}</h1>
+
+      <form action={handleUpdate} className="space-y-5">
+${fields.map((f) => generateFormField(f, camelName, true)).join("\n\n")}
+
+        <div className="flex gap-3 pt-4">
+          <button
+            type="submit"
+            className="rounded-lg bg-gray-900 px-4 py-2 text-sm font-medium text-white transition-colors hover:bg-gray-800"
+          >
+            Update ${pascalName}
+          </button>
+          <Link
+            href="/${kebabPlural}"
+            className="rounded-lg border border-gray-200 px-4 py-2 text-sm font-medium text-gray-600 transition-colors hover:bg-gray-50"
+          >
+            Cancel
+          </Link>
+        </div>
+      </form>
+    </div>
+  );
+}
+`;
+}
+function generateFormField(field, camelName, withDefault = false) {
+  const label = toPascalCase(field.name);
+  const defaultValue = withDefault ? ` defaultValue={${camelName}.${field.name}}` : "";
+  const inputClasses = "mt-1.5 block w-full rounded-lg border border-gray-200 px-3 py-2 text-gray-900 placeholder:text-gray-400 focus:border-gray-400 focus:outline-none focus:ring-0";
+  const selectClasses = "mt-1.5 block w-full rounded-lg border border-gray-200 px-3 py-2 text-gray-900 focus:border-gray-400 focus:outline-none focus:ring-0";
+  const optionalLabel = field.nullable ? ` <span className="text-gray-400">(optional)</span>` : "";
+  const required = field.nullable ? "" : " required";
+  if (field.type === "text" || field.type === "json") {
+    const rows = field.type === "json" ? 6 : 4;
+    const placeholder = field.type === "json" ? ` placeholder="{}"` : "";
+    return `        <div>
+          <label htmlFor="${field.name}" className="block text-sm font-medium text-gray-700">
+            ${label}${optionalLabel}
+          </label>
+          <textarea
+            id="${field.name}"
+            name="${field.name}"
+            rows={${rows}}
+            className="${inputClasses} resize-none"${defaultValue}${placeholder}${required}
+          />
+        </div>`;
+  }
+  if (field.type === "boolean" || field.type === "bool") {
+    const defaultChecked = withDefault ? ` defaultChecked={${camelName}.${field.name}}` : "";
+    return `        <div className="flex items-center gap-2">
+          <input
+            type="checkbox"
+            id="${field.name}"
+            name="${field.name}"
+            className="h-4 w-4 rounded border-gray-300 text-gray-900 focus:ring-0 focus:ring-offset-0"${defaultChecked}
+          />
+          <label htmlFor="${field.name}" className="text-sm font-medium text-gray-700">
+            ${label}
+          </label>
+        </div>`;
+  }
+  if (field.type === "integer" || field.type === "int" || field.type === "bigint") {
+    return `        <div>
+          <label htmlFor="${field.name}" className="block text-sm font-medium text-gray-700">
+            ${label}${optionalLabel}
+          </label>
+          <input
+            type="number"
+            id="${field.name}"
+            name="${field.name}"
+            className="${inputClasses}"${defaultValue}${required}
+          />
+        </div>`;
+  }
+  if (field.type === "float" || field.type === "decimal") {
+    const step = field.type === "decimal" ? "0.01" : "any";
+    return `        <div>
+          <label htmlFor="${field.name}" className="block text-sm font-medium text-gray-700">
+            ${label}${optionalLabel}
+          </label>
+          <input
+            type="number"
+            step="${step}"
+            id="${field.name}"
+            name="${field.name}"
+            className="${inputClasses}"${defaultValue}${required}
+          />
+        </div>`;
+  }
+  if (field.type === "date") {
+    const dateDefault = withDefault ? ` defaultValue={${camelName}.${field.name}?.toISOString().split("T")[0]}` : "";
+    return `        <div>
+          <label htmlFor="${field.name}" className="block text-sm font-medium text-gray-700">
+            ${label}${optionalLabel}
+          </label>
+          <input
+            type="date"
+            id="${field.name}"
+            name="${field.name}"
+            className="${inputClasses}"${dateDefault}${required}
+          />
+        </div>`;
+  }
+  if (field.type === "datetime" || field.type === "timestamp") {
+    const dateDefault = withDefault ? ` defaultValue={${camelName}.${field.name}?.toISOString().slice(0, 16)}` : "";
+    return `        <div>
+          <label htmlFor="${field.name}" className="block text-sm font-medium text-gray-700">
+            ${label}${optionalLabel}
+          </label>
+          <input
+            type="datetime-local"
+            id="${field.name}"
+            name="${field.name}"
+            className="${inputClasses}"${dateDefault}${required}
+          />
+        </div>`;
+  }
+  if (field.isEnum && field.enumValues) {
+    const options = field.enumValues.map((v) => `            <option value="${v}">${toPascalCase(v)}</option>`).join("\n");
+    return `        <div>
+          <label htmlFor="${field.name}" className="block text-sm font-medium text-gray-700">
+            ${label}${optionalLabel}
+          </label>
+          <select
+            id="${field.name}"
+            name="${field.name}"
+            className="${selectClasses}"${defaultValue}${required}
+          >
+${options}
+          </select>
+        </div>`;
+  }
+  return `        <div>
+          <label htmlFor="${field.name}" className="block text-sm font-medium text-gray-700">
+            ${label}${optionalLabel}
+          </label>
+          <input
+            type="text"
+            id="${field.name}"
+            name="${field.name}"
+            className="${inputClasses}"${defaultValue}${required}
+          />
+        </div>`;
+}
+function formDataValue(field) {
+  const getValue = `formData.get("${field.name}")`;
+  const asString = `${getValue} as string`;
+  if (field.nullable) {
+    if (field.type === "integer" || field.type === "int" || field.type === "bigint") {
+      return `${getValue} ? parseInt(${asString}) : null`;
+    }
+    if (field.type === "float") {
+      return `${getValue} ? parseFloat(${asString}) : null`;
+    }
+    if (field.type === "decimal") {
+      return `${getValue} ? ${asString} : null`;
+    }
+    if (field.type === "datetime" || field.type === "timestamp" || field.type === "date") {
+      return `${getValue} ? new Date(${asString}) : null`;
+    }
+    if (field.type === "json") {
+      return `${getValue} ? JSON.parse(${asString}) : null`;
+    }
+    return `${getValue} ? ${asString} : null`;
+  }
+  if (field.type === "boolean" || field.type === "bool") {
+    return `${getValue} === "on"`;
+  }
+  if (field.type === "integer" || field.type === "int" || field.type === "bigint") {
+    return `parseInt(${asString})`;
+  }
+  if (field.type === "float") {
+    return `parseFloat(${asString})`;
+  }
+  if (field.type === "datetime" || field.type === "timestamp" || field.type === "date") {
+    return `new Date(${asString})`;
+  }
+  if (field.type === "json") {
+    return `JSON.parse(${asString})`;
+  }
+  return asString;
+}
+
+// src/generators/resource.ts
+function generateResource(name, fieldArgs, options = {}) {
+  validateModelName(name);
+  const ctx = createModelContext(name);
+  const prefix = options.dryRun ? "[dry-run] " : "";
+  log.info(`
+${prefix}Generating resource ${ctx.pascalName}...
+`);
+  generateModel(ctx.singularName, fieldArgs, options);
+  generateActions(ctx.singularName, options);
+  log.info(`
+Next steps:`);
+  log.info(`  1. Run 'pnpm db:push' to update the database`);
+  log.info(`  2. Create pages in app/${ctx.kebabPlural}/`);
+}
+
+// src/generators/api.ts
+import * as path5 from "path";
+function generateApi(name, fieldArgs, options = {}) {
+  validateModelName(name);
+  const ctx = createModelContext(name);
+  const prefix = options.dryRun ? "[dry-run] " : "";
+  log.info(`
+${prefix}Generating API ${ctx.pascalName}...
+`);
+  generateModel(ctx.singularName, fieldArgs, options);
+  generateRoutes(ctx.camelPlural, ctx.kebabPlural, options);
+  log.info(`
+Next steps:`);
+  log.info(`  1. Run 'pnpm db:push' to update the database`);
+  log.info(`  2. API available at /api/${ctx.kebabPlural}`);
+}
+function generateRoutes(camelPlural, kebabPlural, options) {
+  const basePath = path5.join(getAppPath(), "api", kebabPlural);
+  writeFile(
+    path5.join(basePath, "route.ts"),
+    generateCollectionRoute(camelPlural),
+    options
+  );
+  writeFile(
+    path5.join(basePath, "[id]", "route.ts"),
+    generateMemberRoute(camelPlural),
+    options
+  );
+}
+function generateCollectionRoute(camelPlural) {
+  const dbImport = getDbImport();
+  const schemaImport = getSchemaImport();
+  return `import { db } from "${dbImport}";
+import { ${camelPlural} } from "${schemaImport}";
+import { desc } from "drizzle-orm";
+import { NextResponse } from "next/server";
+
+export async function GET() {
+  try {
+    const data = await db
+      .select()
+      .from(${camelPlural})
+      .orderBy(desc(${camelPlural}.createdAt));
+
+    return NextResponse.json(data);
+  } catch {
+    return NextResponse.json(
+      { error: "Failed to fetch records" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const result = await db.insert(${camelPlural}).values(body).returning();
+
+    return NextResponse.json(result[0], { status: 201 });
+  } catch {
+    return NextResponse.json(
+      { error: "Failed to create record" },
+      { status: 500 }
+    );
+  }
+}
+`;
+}
+function generateMemberRoute(camelPlural) {
+  const dbImport = getDbImport();
+  const schemaImport = getSchemaImport();
+  return `import { db } from "${dbImport}";
+import { ${camelPlural} } from "${schemaImport}";
+import { eq } from "drizzle-orm";
+import { NextResponse } from "next/server";
+
+type Params = { params: Promise<{ id: string }> };
+
+export async function GET(request: Request, { params }: Params) {
+  try {
+    const { id } = await params;
+    const result = await db
+      .select()
+      .from(${camelPlural})
+      .where(eq(${camelPlural}.id, parseInt(id)))
+      .limit(1);
+
+    if (!result[0]) {
+      return NextResponse.json(
+        { error: "Record not found" },
+        { status: 404 }
+      );
+    }
+
+    return NextResponse.json(result[0]);
+  } catch {
+    return NextResponse.json(
+      { error: "Failed to fetch record" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PATCH(request: Request, { params }: Params) {
+  try {
+    const { id } = await params;
+    const body = await request.json();
+    const result = await db
+      .update(${camelPlural})
+      .set({ ...body, updatedAt: new Date() })
+      .where(eq(${camelPlural}.id, parseInt(id)))
+      .returning();
+
+    if (!result[0]) {
+      return NextResponse.json(
+        { error: "Record not found" },
+        { status: 404 }
+      );
+    }
+
+    return NextResponse.json(result[0]);
+  } catch {
+    return NextResponse.json(
+      { error: "Failed to update record" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(request: Request, { params }: Params) {
+  try {
+    const { id } = await params;
+    await db.delete(${camelPlural}).where(eq(${camelPlural}.id, parseInt(id)));
+
+    return new NextResponse(null, { status: 204 });
+  } catch {
+    return NextResponse.json(
+      { error: "Failed to delete record" },
+      { status: 500 }
+    );
+  }
+}
+`;
+}
+
+// src/generators/destroy.ts
+import * as path6 from "path";
+function destroyScaffold(name, options = {}) {
+  validateModelName(name);
+  const ctx = createModelContext(name);
+  const config = detectProjectConfig();
+  const prefix = options.dryRun ? "[dry-run] " : "";
+  log.info(`
+${prefix}Destroying scaffold ${ctx.pascalName}...
+`);
+  const basePath = path6.join(getAppPath(), ctx.kebabPlural);
+  deleteDirectory(basePath, options);
+  log.info(`
+Note: Schema in ${config.dbPath}/schema.ts was not modified.`);
+  log.info(`      Remove the table definition manually if needed.`);
+}
+function destroyResource(name, options = {}) {
+  validateModelName(name);
+  const ctx = createModelContext(name);
+  const config = detectProjectConfig();
+  const prefix = options.dryRun ? "[dry-run] " : "";
+  log.info(`
+${prefix}Destroying resource ${ctx.pascalName}...
+`);
+  const basePath = path6.join(getAppPath(), ctx.kebabPlural);
+  deleteDirectory(basePath, options);
+  log.info(`
+Note: Schema in ${config.dbPath}/schema.ts was not modified.`);
+  log.info(`      Remove the table definition manually if needed.`);
+}
+function destroyApi(name, options = {}) {
+  validateModelName(name);
+  const ctx = createModelContext(name);
+  const config = detectProjectConfig();
+  const prefix = options.dryRun ? "[dry-run] " : "";
+  log.info(`
+${prefix}Destroying API ${ctx.pascalName}...
+`);
+  const basePath = path6.join(getAppPath(), "api", ctx.kebabPlural);
+  deleteDirectory(basePath, options);
+  log.info(`
+Note: Schema in ${config.dbPath}/schema.ts was not modified.`);
+  log.info(`      Remove the table definition manually if needed.`);
+}
+
+// src/index.ts
+function handleError(error) {
+  if (error instanceof Error) {
+    log.error(error.message);
+  } else {
+    log.error(String(error));
+  }
+  process.exit(1);
+}
+program.name("drizzle-gen").description("Rails-like generators for Next.js + Drizzle").version("0.1.0");
+program.command("model <name> [fields...]").description(
+  `Generate a Drizzle schema model
+
+  Examples:
+    drizzle-gen model user name:string email:string:unique
+    drizzle-gen model post title:string body:text published:boolean
+    drizzle-gen model order total:decimal status:enum:pending,paid,shipped
+    drizzle-gen model token value:uuid --uuid --no-timestamps
+    drizzle-gen model comment content:text? author:string`
+).option("-f, --force", "Overwrite existing files").option("-n, --dry-run", "Preview changes without writing files").option("-u, --uuid", "Use UUID for primary key instead of auto-increment").option("--no-timestamps", "Skip createdAt/updatedAt fields").action((name, fields, opts) => {
+  try {
+    generateModel(name, fields, {
+      ...opts,
+      noTimestamps: opts.timestamps === false
+    });
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("actions <name>").description(
+  `Generate server actions for an existing model
+
+  Examples:
+    drizzle-gen actions user
+    drizzle-gen actions post --force`
+).option("-f, --force", "Overwrite existing files").option("-n, --dry-run", "Preview changes without writing files").action((name, opts) => {
+  try {
+    generateActions(name, opts);
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("resource <name> [fields...]").description(
+  `Generate model and actions (no views)
+
+  Examples:
+    drizzle-gen resource user name:string email:string:unique
+    drizzle-gen resource session token:uuid userId:references:user --uuid`
+).option("-f, --force", "Overwrite existing files").option("-n, --dry-run", "Preview changes without writing files").option("-u, --uuid", "Use UUID for primary key instead of auto-increment").option("--no-timestamps", "Skip createdAt/updatedAt fields").action((name, fields, opts) => {
+  try {
+    generateResource(name, fields, {
+      ...opts,
+      noTimestamps: opts.timestamps === false
+    });
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("scaffold <name> [fields...]").description(
+  `Generate model, actions, and pages (full CRUD)
+
+  Examples:
+    drizzle-gen scaffold post title:string body:text published:boolean
+    drizzle-gen scaffold product name:string price:float description:text?
+    drizzle-gen scaffold order status:enum:pending,processing,shipped,delivered`
+).option("-f, --force", "Overwrite existing files").option("-n, --dry-run", "Preview changes without writing files").option("-u, --uuid", "Use UUID for primary key instead of auto-increment").option("--no-timestamps", "Skip createdAt/updatedAt fields").action((name, fields, opts) => {
+  try {
+    generateScaffold(name, fields, {
+      ...opts,
+      noTimestamps: opts.timestamps === false
+    });
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("api <name> [fields...]").description(
+  `Generate model and API route handlers (REST)
+
+  Examples:
+    drizzle-gen api product name:string price:float
+    drizzle-gen api webhook url:string secret:string:unique --uuid`
+).option("-f, --force", "Overwrite existing files").option("-n, --dry-run", "Preview changes without writing files").option("-u, --uuid", "Use UUID for primary key instead of auto-increment").option("--no-timestamps", "Skip createdAt/updatedAt fields").action((name, fields, opts) => {
+  try {
+    generateApi(name, fields, {
+      ...opts,
+      noTimestamps: opts.timestamps === false
+    });
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("destroy <type> <name>").alias("d").description(
+  `Remove generated files (scaffold, resource, api)
+
+  Examples:
+    drizzle-gen destroy scaffold post
+    drizzle-gen d api product --dry-run`
+).option("-n, --dry-run", "Preview changes without deleting files").action((type, name, opts) => {
+  try {
+    switch (type) {
+      case "scaffold":
+        destroyScaffold(name, opts);
+        break;
+      case "resource":
+        destroyResource(name, opts);
+        break;
+      case "api":
+        destroyApi(name, opts);
+        break;
+      default:
+        throw new Error(`Unknown type "${type}". Use: scaffold, resource, or api`);
+    }
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("config").description("Show detected project configuration").action(() => {
+  const config = detectProjectConfig();
+  const dialect = detectDialect();
+  console.log("\nDetected project configuration:\n");
+  console.log(`  Project structure:  ${config.useSrc ? "src/ (e.g., src/app/, src/db/)" : "root (e.g., app/, db/)"}`);
+  console.log(`  Path alias:         ${config.alias}/`);
+  console.log(`  App directory:      ${config.appPath}/`);
+  console.log(`  DB directory:       ${config.dbPath}/`);
+  console.log(`  Database dialect:   ${dialect}`);
+  console.log();
+  console.log("Imports will use:");
+  console.log(`  DB:     ${config.alias}/${config.dbPath.replace(/^src\//, "")}`);
+  console.log(`  Schema: ${config.alias}/${config.dbPath.replace(/^src\//, "")}/schema`);
+  console.log();
+});
+program.parse();