brizzle 0.2.9 → 0.3.0

package/dist/index.js

@@ -5,7 +5,7 @@ import { program } from "commander";
 import { createRequire } from "module";
 
 // src/generators/model.ts
-import * as path4 from "path";
+import * as path5 from "path";
 
 // src/lib/types.ts
 var VALID_FIELD_TYPES = [
@@ -27,11 +27,71 @@ var VALID_FIELD_TYPES = [
 
 // src/lib/config.ts
 import * as fs from "fs";
+import * as path2 from "path";
+
+// src/lib/logger.ts
 import * as path from "path";
+var log = {
+  /** Log file creation (green) */
+  create: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`      \x1B[32mcreate\x1B[0m  ${relative2}`);
+  },
+  /** Log file overwrite with --force (yellow) */
+  force: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`       \x1B[33mforce\x1B[0m  ${relative2}`);
+  },
+  /** Log file skip (exists, no --force) (yellow) */
+  skip: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`        \x1B[33mskip\x1B[0m  ${relative2}`);
+  },
+  /** Log file/directory removal (red) */
+  remove: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`      \x1B[31mremove\x1B[0m  ${relative2}`);
+  },
+  /** Log file not found (yellow) */
+  notFound: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`   \x1B[33mnot found\x1B[0m  ${relative2}`);
+  },
+  /** Log dry-run file creation (cyan) */
+  wouldCreate: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`\x1B[36mwould create\x1B[0m  ${relative2}`);
+  },
+  /** Log dry-run file overwrite (cyan) */
+  wouldForce: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(` \x1B[36mwould force\x1B[0m  ${relative2}`);
+  },
+  /** Log dry-run file removal (cyan) */
+  wouldRemove: (filePath) => {
+    const relative2 = path.relative(process.cwd(), filePath);
+    console.log(`\x1B[36mwould remove\x1B[0m  ${relative2}`);
+  },
+  /** Log error message (red) */
+  error: (message) => {
+    console.error(`\x1B[31mError:\x1B[0m ${message}`);
+  },
+  /** Log warning message (yellow) */
+  warn: (message) => {
+    console.warn(`\x1B[33mWarning:\x1B[0m ${message}`);
+  },
+  /** Log info message (no color) */
+  info: (message) => {
+    console.log(message);
+  }
+};
+
+// src/lib/config.ts
 var cachedProjectConfig = null;
 function detectDialect() {
-  const configPath = path.join(process.cwd(), "drizzle.config.ts");
+  const configPath = path2.join(process.cwd(), "drizzle.config.ts");
   if (!fs.existsSync(configPath)) {
+    log.warn("drizzle.config.ts not found, defaulting to sqlite dialect");
     return "sqlite";
   }
   const content = fs.readFileSync(configPath, "utf-8");
@@ -52,9 +112,9 @@ function detectProjectConfig() {
     return cachedProjectConfig;
   }
   const cwd = process.cwd();
-  const useSrc = fs.existsSync(path.join(cwd, "src", "app"));
+  const useSrc = fs.existsSync(path2.join(cwd, "src", "app"));
   let alias = "@";
-  const tsconfigPath = path.join(cwd, "tsconfig.json");
+  const tsconfigPath = path2.join(cwd, "tsconfig.json");
   if (fs.existsSync(tsconfigPath)) {
     try {
       const content = fs.readFileSync(tsconfigPath, "utf-8");
@@ -76,7 +136,7 @@ function detectProjectConfig() {
   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))) {
+    if (fs.existsSync(path2.join(cwd, possiblePath))) {
       dbPath = possiblePath;
       break;
     }
@@ -95,55 +155,23 @@ function getSchemaImport() {
 }
 function getAppPath() {
   const config = detectProjectConfig();
-  return path.join(process.cwd(), config.appPath);
+  return path2.join(process.cwd(), config.appPath);
 }
 function getDbPath() {
   const config = detectProjectConfig();
-  return path.join(process.cwd(), config.dbPath);
+  return path2.join(process.cwd(), config.dbPath);
+}
+function detectPackageManager() {
+  const cwd = process.cwd();
+  if (fs.existsSync(path2.join(cwd, "bun.lockb"))) return "bun";
+  if (fs.existsSync(path2.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path2.join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function getRunCommand() {
+  const pm = detectPackageManager();
+  return pm === "npm" ? "npm run" : pm;
 }
-
-// src/lib/logger.ts
-import * as path2 from "path";
-var log = {
-  create: (filePath) => {
-    const relative2 = path2.relative(process.cwd(), filePath);
-    console.log(`      \x1B[32mcreate\x1B[0m  ${relative2}`);
-  },
-  force: (filePath) => {
-    const relative2 = path2.relative(process.cwd(), filePath);
-    console.log(`       \x1B[33mforce\x1B[0m  ${relative2}`);
-  },
-  skip: (filePath) => {
-    const relative2 = path2.relative(process.cwd(), filePath);
-    console.log(`        \x1B[33mskip\x1B[0m  ${relative2}`);
-  },
-  remove: (filePath) => {
-    const relative2 = path2.relative(process.cwd(), filePath);
-    console.log(`      \x1B[31mremove\x1B[0m  ${relative2}`);
-  },
-  notFound: (filePath) => {
-    const relative2 = path2.relative(process.cwd(), filePath);
-    console.log(`   \x1B[33mnot found\x1B[0m  ${relative2}`);
-  },
-  wouldCreate: (filePath) => {
-    const relative2 = path2.relative(process.cwd(), filePath);
-    console.log(`\x1B[36mwould create\x1B[0m  ${relative2}`);
-  },
-  wouldForce: (filePath) => {
-    const relative2 = path2.relative(process.cwd(), filePath);
-    console.log(` \x1B[36mwould force\x1B[0m  ${relative2}`);
-  },
-  wouldRemove: (filePath) => {
-    const relative2 = path2.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);
-  }
-};
 
 // src/lib/strings.ts
 import pluralizeLib from "pluralize";
@@ -188,7 +216,107 @@ function createModelContext(name) {
   };
 }
 
+// src/lib/files.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+function writeFile(filePath, content, options = {}) {
+  const exists = fs2.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 = path3.dirname(filePath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  fs2.writeFileSync(filePath, content);
+  if (exists && options.force) {
+    log.force(filePath);
+  } else {
+    log.create(filePath);
+  }
+  return true;
+}
+function deleteDirectory(dirPath, options = {}) {
+  if (!fs2.existsSync(dirPath)) {
+    log.notFound(dirPath);
+    return false;
+  }
+  if (options.dryRun) {
+    log.wouldRemove(dirPath);
+    return true;
+  }
+  fs2.rmSync(dirPath, { recursive: true });
+  log.remove(dirPath);
+  return true;
+}
+function fileExists(filePath) {
+  return fs2.existsSync(filePath);
+}
+function readFile(filePath) {
+  return fs2.readFileSync(filePath, "utf-8");
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function modelExistsInSchema(tableName) {
+  const schemaPath = path3.join(getDbPath(), "schema.ts");
+  if (!fs2.existsSync(schemaPath)) {
+    return false;
+  }
+  const content = fs2.readFileSync(schemaPath, "utf-8");
+  const pattern = new RegExp(
+    `(?:sqliteTable|pgTable|mysqlTable)\\s*\\(\\s*["']${escapeRegExp(tableName)}["']`
+  );
+  return pattern.test(content);
+}
+function removeModelFromSchemaContent(content, tableName) {
+  const lines = content.split("\n");
+  const tablePattern = new RegExp(
+    `^export\\s+const\\s+\\w+\\s*=\\s*(?:sqliteTable|pgTable|mysqlTable)\\s*\\(\\s*["']${escapeRegExp(tableName)}["']`
+  );
+  let startIdx = -1;
+  let endIdx = -1;
+  let braceCount = 0;
+  let foundOpenBrace = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (startIdx === -1) {
+      if (tablePattern.test(lines[i])) {
+        startIdx = i;
+      } else {
+        continue;
+      }
+    }
+    for (const char of lines[i]) {
+      if (char === "{") {
+        braceCount++;
+        foundOpenBrace = true;
+      } else if (char === "}") {
+        braceCount--;
+      }
+    }
+    if (foundOpenBrace && braceCount === 0) {
+      endIdx = i;
+      break;
+    }
+  }
+  if (startIdx === -1 || endIdx === -1) {
+    return content;
+  }
+  lines.splice(startIdx, endIdx - startIdx + 1);
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+
 // src/lib/validation.ts
+import * as path4 from "path";
 var SQL_RESERVED_WORDS = [
   // SQL keywords
   "select",
@@ -319,9 +447,7 @@ function validateFieldDefinition(fieldDef) {
     const values = enumValues.split(",");
     for (const value of values) {
       if (!value) {
-        throw new Error(
-          `Enum field "${name}" has an empty value. Values must not be empty.`
-        );
+        throw new Error(`Enum field "${name}" has an empty value. Values must not be empty.`);
       }
       if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(value)) {
         throw new Error(
@@ -331,9 +457,24 @@ function validateFieldDefinition(fieldDef) {
     }
     const unique = new Set(values);
     if (unique.size !== values.length) {
-      throw new Error(
-        `Enum field "${name}" has duplicate values.`
-      );
+      throw new Error(`Enum field "${name}" has duplicate values.`);
+    }
+  }
+}
+function validateReferences(fields) {
+  const schemaPath = path4.join(getDbPath(), "schema.ts");
+  if (!fileExists(schemaPath)) {
+    return;
+  }
+  const schemaContent = readFile(schemaPath);
+  for (const field of fields) {
+    if (field.isReference && field.referenceTo) {
+      const tableName = toSnakeCase(pluralize(field.referenceTo));
+      if (!schemaContent.includes(`"${tableName}"`)) {
+        log.warn(
+          `Referenced model "${field.referenceTo}" (table "${tableName}") not found in schema. Make sure to create it before running migrations.`
+        );
+      }
     }
   }
 }
@@ -380,7 +521,7 @@ function parseFields(fields) {
   });
 }
 
-// src/lib/drizzle.ts
+// src/lib/drizzle/types.ts
 var SQLITE_TYPE_MAP = {
   string: "text",
   text: "text",
@@ -438,16 +579,8 @@ 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";
-  }
-}
+
+// src/lib/drizzle/columns.ts
 function getTableFunction(dialect) {
   switch (dialect) {
     case "postgresql":
@@ -506,6 +639,18 @@ function getTimestampColumns(dialect, noTimestamps = false) {
     .$defaultFn(() => new Date())`;
   }
 }
+
+// src/lib/drizzle/imports.ts
+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 extractImportsFromSchema(content) {
   const importMatch = content.match(/import\s*\{([^}]+)\}\s*from\s*["']drizzle-orm\/[^"']+["']/);
   if (!importMatch) {
@@ -571,103 +716,197 @@ 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 = fs2.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 = path3.dirname(filePath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  fs2.writeFileSync(filePath, content);
-  if (exists && options.force) {
-    log.force(filePath);
-  } else {
-    log.create(filePath);
-  }
-  return true;
+// src/lib/forms.ts
+function createFieldContext(field, camelName, withDefault) {
+  return {
+    field,
+    label: toPascalCase(field.name),
+    optionalLabel: field.nullable ? ` <span className="text-zinc-400 dark:text-zinc-500">(optional)</span>` : "",
+    required: field.nullable ? "" : " required",
+    defaultValue: withDefault ? ` defaultValue={${camelName}.${field.name}}` : ""
+  };
 }
-function deleteDirectory(dirPath, options = {}) {
-  if (!fs2.existsSync(dirPath)) {
-    log.notFound(dirPath);
-    return false;
-  }
-  if (options.dryRun) {
-    log.wouldRemove(dirPath);
-    return true;
-  }
-  fs2.rmSync(dirPath, { recursive: true });
-  log.remove(dirPath);
-  return true;
+function generateTextareaField(ctx) {
+  const { field, label, optionalLabel, required, defaultValue } = ctx;
+  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-zinc-700 dark:text-zinc-300">
+            ${label}${optionalLabel}
+          </label>
+          <textarea
+            id="${field.name}"
+            name="${field.name}"
+            rows={${rows}}
+            className="mt-1.5 block w-full rounded-lg border border-zinc-200 bg-white px-3 py-2 text-zinc-900 placeholder:text-zinc-400 focus:border-zinc-400 focus:outline-none dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-50 dark:placeholder:text-zinc-500 dark:focus:border-zinc-500 resize-none"${defaultValue}${placeholder}${required}
+          />
+        </div>`;
 }
-function fileExists(filePath) {
-  return fs2.existsSync(filePath);
+function generateCheckboxField(ctx, camelName, withDefault) {
+  const { field, label } = ctx;
+  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-zinc-300 text-zinc-900 focus:ring-0 focus:ring-offset-0 dark:border-zinc-600 dark:bg-zinc-800 dark:text-zinc-50"${defaultChecked}
+          />
+          <label htmlFor="${field.name}" className="text-sm font-medium text-zinc-700 dark:text-zinc-300">
+            ${label}
+          </label>
+        </div>`;
 }
-function readFile(filePath) {
-  return fs2.readFileSync(filePath, "utf-8");
+function generateNumberField(ctx, step) {
+  const { field, label, optionalLabel, required, defaultValue } = ctx;
+  const stepAttr = step ? `
+            step="${step}"` : "";
+  return `        <div>
+          <label htmlFor="${field.name}" className="block text-sm font-medium text-zinc-700 dark:text-zinc-300">
+            ${label}${optionalLabel}
+          </label>
+          <input
+            type="number"${stepAttr}
+            id="${field.name}"
+            name="${field.name}"
+            className="mt-1.5 block w-full rounded-lg border border-zinc-200 bg-white px-3 py-2 text-zinc-900 placeholder:text-zinc-400 focus:border-zinc-400 focus:outline-none dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-50 dark:placeholder:text-zinc-500 dark:focus:border-zinc-500"${defaultValue}${required}
+          />
+        </div>`;
 }
-function escapeRegExp(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function generateDateField(ctx, camelName, withDefault) {
+  const { field, label, optionalLabel, required } = ctx;
+  const dateDefault = withDefault ? ` defaultValue={${camelName}.${field.name}?.toISOString().split("T")[0]}` : "";
+  return `        <div>
+          <label htmlFor="${field.name}" className="block text-sm font-medium text-zinc-700 dark:text-zinc-300">
+            ${label}${optionalLabel}
+          </label>
+          <input
+            type="date"
+            id="${field.name}"
+            name="${field.name}"
+            className="mt-1.5 block w-full rounded-lg border border-zinc-200 bg-white px-3 py-2 text-zinc-900 placeholder:text-zinc-400 focus:border-zinc-400 focus:outline-none dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-50 dark:placeholder:text-zinc-500 dark:focus:border-zinc-500"${dateDefault}${required}
+          />
+        </div>`;
 }
-function modelExistsInSchema(tableName) {
-  const schemaPath = path3.join(getDbPath(), "schema.ts");
-  if (!fs2.existsSync(schemaPath)) {
-    return false;
-  }
-  const content = fs2.readFileSync(schemaPath, "utf-8");
-  const pattern = new RegExp(
-    `(?:sqliteTable|pgTable|mysqlTable)\\s*\\(\\s*["']${escapeRegExp(tableName)}["']`
-  );
-  return pattern.test(content);
+function generateDatetimeField(ctx, camelName, withDefault) {
+  const { field, label, optionalLabel, required } = ctx;
+  const dateDefault = withDefault ? ` defaultValue={${camelName}.${field.name}?.toISOString().slice(0, 16)}` : "";
+  return `        <div>
+          <label htmlFor="${field.name}" className="block text-sm font-medium text-zinc-700 dark:text-zinc-300">
+            ${label}${optionalLabel}
+          </label>
+          <input
+            type="datetime-local"
+            id="${field.name}"
+            name="${field.name}"
+            className="mt-1.5 block w-full rounded-lg border border-zinc-200 bg-white px-3 py-2 text-zinc-900 placeholder:text-zinc-400 focus:border-zinc-400 focus:outline-none dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-50 dark:placeholder:text-zinc-500 dark:focus:border-zinc-500"${dateDefault}${required}
+          />
+        </div>`;
 }
-function removeModelFromSchemaContent(content, tableName) {
-  const lines = content.split("\n");
-  const tablePattern = new RegExp(
-    `^export\\s+const\\s+\\w+\\s*=\\s*(?:sqliteTable|pgTable|mysqlTable)\\s*\\(\\s*["']${escapeRegExp(tableName)}["']`
-  );
-  let startIdx = -1;
-  let endIdx = -1;
-  let braceCount = 0;
-  let foundOpenBrace = false;
-  for (let i = 0; i < lines.length; i++) {
-    if (startIdx === -1) {
-      if (tablePattern.test(lines[i])) {
-        startIdx = i;
-      } else {
-        continue;
+function generateSelectField(ctx) {
+  const { field, label, optionalLabel, required, defaultValue } = ctx;
+  const options = field.enumValues.map(
+    (v) => `            <option value="${escapeString(v)}">${toPascalCase(v)}</option>`
+  ).join("\n");
+  return `        <div>
+          <label htmlFor="${field.name}" className="block text-sm font-medium text-zinc-700 dark:text-zinc-300">
+            ${label}${optionalLabel}
+          </label>
+          <select
+            id="${field.name}"
+            name="${field.name}"
+            className="mt-1.5 block w-full rounded-lg border border-zinc-200 bg-white px-3 py-2 text-zinc-900 focus:border-zinc-400 focus:outline-none dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-50 dark:focus:border-zinc-500"${defaultValue}${required}
+          >
+${options}
+          </select>
+        </div>`;
+}
+function generateTextField(ctx) {
+  const { field, label, optionalLabel, required, defaultValue } = ctx;
+  return `        <div>
+          <label htmlFor="${field.name}" className="block text-sm font-medium text-zinc-700 dark:text-zinc-300">
+            ${label}${optionalLabel}
+          </label>
+          <input
+            type="text"
+            id="${field.name}"
+            name="${field.name}"
+            className="mt-1.5 block w-full rounded-lg border border-zinc-200 bg-white px-3 py-2 text-zinc-900 placeholder:text-zinc-400 focus:border-zinc-400 focus:outline-none dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-50 dark:placeholder:text-zinc-500 dark:focus:border-zinc-500"${defaultValue}${required}
+          />
+        </div>`;
+}
+function generateFormField(field, camelName, withDefault = false) {
+  const ctx = createFieldContext(field, camelName, withDefault);
+  switch (field.type) {
+    case "text":
+    case "json":
+      return generateTextareaField(ctx);
+    case "boolean":
+    case "bool":
+      return generateCheckboxField(ctx, camelName, withDefault);
+    case "integer":
+    case "int":
+    case "bigint":
+      return generateNumberField(ctx);
+    case "float":
+      return generateNumberField(ctx, "any");
+    case "decimal":
+      return generateNumberField(ctx, "0.01");
+    case "date":
+      return generateDateField(ctx, camelName, withDefault);
+    case "datetime":
+    case "timestamp":
+      return generateDatetimeField(ctx, camelName, withDefault);
+    default:
+      if (field.isEnum && field.enumValues) {
+        return generateSelectField(ctx);
       }
+      return generateTextField(ctx);
+  }
+}
+function formDataValue(field) {
+  const getValue = `formData.get("${field.name}")`;
+  const asString = `${getValue} as string`;
+  if (field.nullable) {
+    if (field.type === "boolean" || field.type === "bool") {
+      return `${getValue} === "on" ? true : null`;
     }
-    for (const char of lines[i]) {
-      if (char === "{") {
-        braceCount++;
-        foundOpenBrace = true;
-      } else if (char === "}") {
-        braceCount--;
-      }
+    if (field.type === "integer" || field.type === "int" || field.type === "bigint") {
+      return `${getValue} ? parseInt(${asString}) : null`;
     }
-    if (foundOpenBrace && braceCount === 0) {
-      endIdx = i;
-      break;
+    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 (startIdx === -1 || endIdx === -1) {
-    return content;
+  if (field.type === "boolean" || field.type === "bool") {
+    return `${getValue} === "on"`;
   }
-  lines.splice(startIdx, endIdx - startIdx + 1);
-  return lines.join("\n").replace(/\n{3,}/g, "\n\n");
+  if (field.type === "integer" || field.type === "int" || field.type === "bigint") {
+    return `parseInt(${asString})`;
+  }
+  if (field.type === "float") {
+    return `parseFloat(${asString})`;
+  }
+  if (field.type === "decimal") {
+    return 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/model.ts
@@ -676,14 +915,21 @@ function generateModel(name, fieldArgs, options = {}) {
   const ctx = createModelContext(name);
   const fields = parseFields(fieldArgs);
   const dialect = detectDialect();
+  validateReferences(fields);
   if (modelExistsInSchema(ctx.tableName) && !options.force) {
     throw new Error(
       `Model "${ctx.pascalName}" already exists in schema. Use --force to regenerate.`
     );
   }
-  const schemaPath = path4.join(getDbPath(), "schema.ts");
+  const schemaPath = path5.join(getDbPath(), "schema.ts");
   if (!fileExists(schemaPath)) {
-    const schemaContent = generateSchemaContent(ctx.camelPlural, ctx.tableName, fields, dialect, options);
+    const schemaContent = generateSchemaContent(
+      ctx.camelPlural,
+      ctx.tableName,
+      fields,
+      dialect,
+      options
+    );
     writeFile(schemaPath, schemaContent, options);
   } else if (modelExistsInSchema(ctx.tableName)) {
     replaceInSchema(schemaPath, ctx.camelPlural, ctx.tableName, fields, dialect, options);
@@ -790,12 +1036,14 @@ function generateEnumField(field, columnName, dialect) {
   switch (dialect) {
     case "postgresql":
       return `  ${field.name}: ${field.name}Enum("${columnName}")${modifiers},`;
-    case "mysql":
+    case "mysql": {
       const mysqlValues = values.map((v) => `"${escapeString(v)}"`).join(", ");
       return `  ${field.name}: mysqlEnum("${columnName}", [${mysqlValues}])${modifiers},`;
-    default:
+    }
+    default: {
       const sqliteValues = values.map((v) => `"${escapeString(v)}"`).join(", ");
       return `  ${field.name}: text("${columnName}", { enum: [${sqliteValues}] })${modifiers},`;
+    }
   }
 }
 function appendToSchema(schemaPath, modelName, tableName, fields, dialect, options) {
@@ -819,23 +1067,23 @@ function replaceInSchema(schemaPath, modelName, tableName, fields, dialect, opti
 }
 
 // src/generators/actions.ts
-import * as path5 from "path";
+import * as path6 from "path";
 function generateActions(name, options = {}) {
   validateModelName(name);
   const ctx = createModelContext(name);
-  const actionsPath = path5.join(
-    getAppPath(),
-    ctx.kebabPlural,
-    "actions.ts"
-  );
-  const content = generateActionsContent(ctx, options);
+  const dialect = detectDialect();
+  const actionsPath = path6.join(getAppPath(), ctx.kebabPlural, "actions.ts");
+  const content = generateActionsContent(ctx, options, dialect);
   writeFile(actionsPath, content, options);
 }
-function generateActionsContent(ctx, options = {}) {
+function generateActionsContent(ctx, options = {}, dialect = "sqlite") {
   const { pascalName, pascalPlural, camelPlural, kebabPlural } = ctx;
   const dbImport = getDbImport();
   const schemaImport = getSchemaImport();
   const idType = options.uuid ? "string" : "number";
+  if (dialect === "mysql") {
+    return generateMySqlActions(ctx, dbImport, schemaImport, idType);
+  }
   return `"use server";
 
 import { db } from "${dbImport}";
@@ -890,49 +1138,77 @@ export async function delete${pascalName}(id: ${idType}) {
 }
 `;
 }
+function generateMySqlActions(ctx, dbImport, schemaImport, idType) {
+  const { pascalName, pascalPlural, camelPlural, kebabPlural } = ctx;
+  return `"use server";
 
-// src/generators/scaffold.ts
-import * as path6 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 = path6.join(getAppPath(), kebabPlural);
-  writeFile(
-    path6.join(basePath, "page.tsx"),
-    generateIndexPage(pascalName, pascalPlural, camelName, kebabPlural, fields),
-    options
-  );
-  writeFile(
-    path6.join(basePath, "new", "page.tsx"),
-    generateNewPage(pascalName, camelName, kebabPlural, fields),
-    options
-  );
-  writeFile(
-    path6.join(basePath, "[id]", "page.tsx"),
-    generateShowPage(pascalName, pascalPlural, camelName, kebabPlural, fields, options),
-    options
-  );
-  writeFile(
-    path6.join(basePath, "[id]", "edit", "page.tsx"),
-    generateEditPage(pascalName, camelName, kebabPlural, fields, options),
-    options
-  );
+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: ${idType}) {
+  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 inserted = await db.insert(${camelPlural}).values(data).$returningId();
+  const result = await db
+    .select()
+    .from(${camelPlural})
+    .where(eq(${camelPlural}.id, inserted[0].id))
+    .limit(1);
+
+  revalidatePath("/${kebabPlural}");
+
+  return result[0];
+}
+
+export async function update${pascalName}(
+  id: ${idType},
+  data: Partial<Omit<New${pascalName}, "id" | "createdAt" | "updatedAt">>
+) {
+  await db
+    .update(${camelPlural})
+    .set({ ...data, updatedAt: new Date() })
+    .where(eq(${camelPlural}.id, id));
+
+  const result = await db
+    .select()
+    .from(${camelPlural})
+    .where(eq(${camelPlural}.id, id))
+    .limit(1);
+
+  revalidatePath("/${kebabPlural}");
+
+  return result[0];
+}
+
+export async function delete${pascalName}(id: ${idType}) {
+  await db.delete(${camelPlural}).where(eq(${camelPlural}.id, id));
+
+  revalidatePath("/${kebabPlural}");
+}
+`;
 }
+
+// src/generators/scaffold.ts
+import * as path7 from "path";
+
+// src/generators/pages/index-page.ts
 function generateIndexPage(pascalName, pascalPlural, camelName, kebabPlural, fields) {
   const displayField = fields[0]?.name || "id";
   return `import Link from "next/link";
@@ -993,6 +1269,8 @@ export default async function ${pascalPlural}Page() {
 }
 `;
 }
+
+// src/generators/pages/new-page.ts
 function generateNewPage(pascalName, camelName, kebabPlural, fields) {
   return `import { redirect } from "next/navigation";
 import Link from "next/link";
@@ -1036,7 +1314,9 @@ ${fields.map((f) => generateFormField(f, camelName)).join("\n\n")}
 }
 `;
 }
-function generateShowPage(pascalName, _pascalPlural, camelName, kebabPlural, fields, options = {}) {
+
+// src/generators/pages/show-page.ts
+function generateShowPage(pascalName, camelName, kebabPlural, fields, options = {}) {
   const idHandling = options.uuid ? `const ${camelName} = await get${pascalName}(id);` : `const numericId = Number(id);
 
   if (isNaN(numericId)) {
@@ -1097,6 +1377,8 @@ ${fields.map(
 }
 `;
 }
+
+// src/generators/pages/edit-page.ts
 function generateEditPage(pascalName, camelName, kebabPlural, fields, options = {}) {
   const idHandling = options.uuid ? `const ${camelName} = await get${pascalName}(id);` : `const numericId = Number(id);
 
@@ -1134,219 +1416,73 @@ ${fields.map((f) => `      ${f.name}: ${formDataValue(f)},`).join("\n")}
 
   return (
     <div className="mx-auto max-w-xl px-6 py-12">
-      <h1 className="mb-8 text-2xl font-semibold tracking-tight text-zinc-900 dark:text-zinc-50">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="flex h-10 items-center rounded-full bg-zinc-900 px-4 text-sm font-medium text-white transition-colors hover:bg-zinc-700 dark:bg-zinc-50 dark:text-zinc-900 dark:hover:bg-zinc-200"
-          >
-            Update ${pascalName}
-          </button>
-          <Link
-            href="/${kebabPlural}"
-            className="flex h-10 items-center rounded-full border border-zinc-200 px-4 text-sm font-medium text-zinc-600 transition-colors hover:bg-zinc-50 dark:border-zinc-700 dark:text-zinc-300 dark:hover:bg-zinc-800"
-          >
-            Cancel
-          </Link>
-        </div>
-      </form>
-    </div>
-  );
-}
-`;
-}
-function createFieldContext(field, camelName, withDefault) {
-  return {
-    field,
-    label: toPascalCase(field.name),
-    optionalLabel: field.nullable ? ` <span className="text-zinc-400 dark:text-zinc-500">(optional)</span>` : "",
-    required: field.nullable ? "" : " required",
-    defaultValue: withDefault ? ` defaultValue={${camelName}.${field.name}}` : ""
-  };
-}
-function generateTextareaField(ctx) {
-  const { field, label, optionalLabel, required, defaultValue } = ctx;
-  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-zinc-700 dark:text-zinc-300">
-            ${label}${optionalLabel}
-          </label>
-          <textarea
-            id="${field.name}"
-            name="${field.name}"
-            rows={${rows}}
-            className="mt-1.5 block w-full rounded-lg border border-zinc-200 bg-white px-3 py-2 text-zinc-900 placeholder:text-zinc-400 focus:border-zinc-400 focus:outline-none dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-50 dark:placeholder:text-zinc-500 dark:focus:border-zinc-500 resize-none"${defaultValue}${placeholder}${required}
-          />
-        </div>`;
-}
-function generateCheckboxField(ctx, camelName, withDefault) {
-  const { field, label } = ctx;
-  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-zinc-300 text-zinc-900 focus:ring-0 focus:ring-offset-0 dark:border-zinc-600 dark:bg-zinc-800 dark:text-zinc-50"${defaultChecked}
-          />
-          <label htmlFor="${field.name}" className="text-sm font-medium text-zinc-700 dark:text-zinc-300">
-            ${label}
-          </label>
-        </div>`;
-}
-function generateNumberField(ctx, step) {
-  const { field, label, optionalLabel, required, defaultValue } = ctx;
-  const stepAttr = step ? `
-            step="${step}"` : "";
-  return `        <div>
-          <label htmlFor="${field.name}" className="block text-sm font-medium text-zinc-700 dark:text-zinc-300">
-            ${label}${optionalLabel}
-          </label>
-          <input
-            type="number"${stepAttr}
-            id="${field.name}"
-            name="${field.name}"
-            className="mt-1.5 block w-full rounded-lg border border-zinc-200 bg-white px-3 py-2 text-zinc-900 placeholder:text-zinc-400 focus:border-zinc-400 focus:outline-none dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-50 dark:placeholder:text-zinc-500 dark:focus:border-zinc-500"${defaultValue}${required}
-          />
-        </div>`;
-}
-function generateDateField(ctx, camelName, withDefault) {
-  const { field, label, optionalLabel, required } = ctx;
-  const dateDefault = withDefault ? ` defaultValue={${camelName}.${field.name}?.toISOString().split("T")[0]}` : "";
-  return `        <div>
-          <label htmlFor="${field.name}" className="block text-sm font-medium text-zinc-700 dark:text-zinc-300">
-            ${label}${optionalLabel}
-          </label>
-          <input
-            type="date"
-            id="${field.name}"
-            name="${field.name}"
-            className="mt-1.5 block w-full rounded-lg border border-zinc-200 bg-white px-3 py-2 text-zinc-900 placeholder:text-zinc-400 focus:border-zinc-400 focus:outline-none dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-50 dark:placeholder:text-zinc-500 dark:focus:border-zinc-500"${dateDefault}${required}
-          />
-        </div>`;
-}
-function generateDatetimeField(ctx, camelName, withDefault) {
-  const { field, label, optionalLabel, required } = ctx;
-  const dateDefault = withDefault ? ` defaultValue={${camelName}.${field.name}?.toISOString().slice(0, 16)}` : "";
-  return `        <div>
-          <label htmlFor="${field.name}" className="block text-sm font-medium text-zinc-700 dark:text-zinc-300">
-            ${label}${optionalLabel}
-          </label>
-          <input
-            type="datetime-local"
-            id="${field.name}"
-            name="${field.name}"
-            className="mt-1.5 block w-full rounded-lg border border-zinc-200 bg-white px-3 py-2 text-zinc-900 placeholder:text-zinc-400 focus:border-zinc-400 focus:outline-none dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-50 dark:placeholder:text-zinc-500 dark:focus:border-zinc-500"${dateDefault}${required}
-          />
-        </div>`;
-}
-function generateSelectField(ctx) {
-  const { field, label, optionalLabel, required, defaultValue } = ctx;
-  const options = field.enumValues.map((v) => `            <option value="${escapeString(v)}">${toPascalCase(v)}</option>`).join("\n");
-  return `        <div>
-          <label htmlFor="${field.name}" className="block text-sm font-medium text-zinc-700 dark:text-zinc-300">
-            ${label}${optionalLabel}
-          </label>
-          <select
-            id="${field.name}"
-            name="${field.name}"
-            className="mt-1.5 block w-full rounded-lg border border-zinc-200 bg-white px-3 py-2 text-zinc-900 focus:border-zinc-400 focus:outline-none dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-50 dark:focus:border-zinc-500"${defaultValue}${required}
-          >
-${options}
-          </select>
-        </div>`;
-}
-function generateTextField(ctx) {
-  const { field, label, optionalLabel, required, defaultValue } = ctx;
-  return `        <div>
-          <label htmlFor="${field.name}" className="block text-sm font-medium text-zinc-700 dark:text-zinc-300">
-            ${label}${optionalLabel}
-          </label>
-          <input
-            type="text"
-            id="${field.name}"
-            name="${field.name}"
-            className="mt-1.5 block w-full rounded-lg border border-zinc-200 bg-white px-3 py-2 text-zinc-900 placeholder:text-zinc-400 focus:border-zinc-400 focus:outline-none dark:border-zinc-700 dark:bg-zinc-900 dark:text-zinc-50 dark:placeholder:text-zinc-500 dark:focus:border-zinc-500"${defaultValue}${required}
-          />
-        </div>`;
-}
-function generateFormField(field, camelName, withDefault = false) {
-  const ctx = createFieldContext(field, camelName, withDefault);
-  switch (field.type) {
-    case "text":
-    case "json":
-      return generateTextareaField(ctx);
-    case "boolean":
-    case "bool":
-      return generateCheckboxField(ctx, camelName, withDefault);
-    case "integer":
-    case "int":
-    case "bigint":
-      return generateNumberField(ctx);
-    case "float":
-      return generateNumberField(ctx, "any");
-    case "decimal":
-      return generateNumberField(ctx, "0.01");
-    case "date":
-      return generateDateField(ctx, camelName, withDefault);
-    case "datetime":
-    case "timestamp":
-      return generateDatetimeField(ctx, camelName, withDefault);
-    default:
-      if (field.isEnum && field.enumValues) {
-        return generateSelectField(ctx);
-      }
-      return generateTextField(ctx);
-  }
-}
-function formDataValue(field) {
-  const getValue = `formData.get("${field.name}")`;
-  const asString = `${getValue} as string`;
-  if (field.nullable) {
-    if (field.type === "boolean" || field.type === "bool") {
-      return `${getValue} === "on" ? true : null`;
-    }
-    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 === "decimal") {
-    return 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;
+      <h1 className="mb-8 text-2xl font-semibold tracking-tight text-zinc-900 dark:text-zinc-50">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="flex h-10 items-center rounded-full bg-zinc-900 px-4 text-sm font-medium text-white transition-colors hover:bg-zinc-700 dark:bg-zinc-50 dark:text-zinc-900 dark:hover:bg-zinc-200"
+          >
+            Update ${pascalName}
+          </button>
+          <Link
+            href="/${kebabPlural}"
+            className="flex h-10 items-center rounded-full border border-zinc-200 px-4 text-sm font-medium text-zinc-600 transition-colors hover:bg-zinc-50 dark:border-zinc-700 dark:text-zinc-300 dark:hover:bg-zinc-800"
+          >
+            Cancel
+          </Link>
+        </div>
+      </form>
+    </div>
+  );
+}
+`;
+}
+
+// src/generators/scaffold.ts
+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);
+  const run = getRunCommand();
+  log.info(`
+Next steps:`);
+  log.info(`  1. Run '${run} db:push' to update the database`);
+  log.info(`  2. Run '${run} dev' and visit /${ctx.kebabPlural}`);
+}
+function generatePages(ctx, fields, options = {}) {
+  const { pascalName, pascalPlural, camelName, kebabPlural } = ctx;
+  const basePath = path7.join(getAppPath(), kebabPlural);
+  writeFile(
+    path7.join(basePath, "page.tsx"),
+    generateIndexPage(pascalName, pascalPlural, camelName, kebabPlural, fields),
+    options
+  );
+  writeFile(
+    path7.join(basePath, "new", "page.tsx"),
+    generateNewPage(pascalName, camelName, kebabPlural, fields),
+    options
+  );
+  writeFile(
+    path7.join(basePath, "[id]", "page.tsx"),
+    generateShowPage(pascalName, camelName, kebabPlural, fields, options),
+    options
+  );
+  writeFile(
+    path7.join(basePath, "[id]", "edit", "page.tsx"),
+    generateEditPage(pascalName, camelName, kebabPlural, fields, options),
+    options
+  );
 }
 
 // src/generators/resource.ts
@@ -1359,14 +1495,15 @@ ${prefix}Generating resource ${ctx.pascalName}...
 `);
   generateModel(ctx.singularName, fieldArgs, options);
   generateActions(ctx.singularName, options);
+  const run = getRunCommand();
   log.info(`
 Next steps:`);
-  log.info(`  1. Run 'pnpm db:push' to update the database`);
+  log.info(`  1. Run '${run} db:push' to update the database`);
   log.info(`  2. Create pages in app/${ctx.kebabPlural}/`);
 }
 
 // src/generators/api.ts
-import * as path7 from "path";
+import * as path8 from "path";
 function generateApi(name, fieldArgs, options = {}) {
   validateModelName(name);
   const ctx = createModelContext(name);
@@ -1376,20 +1513,21 @@ ${prefix}Generating API ${ctx.pascalName}...
 `);
   generateModel(ctx.singularName, fieldArgs, options);
   generateRoutes(ctx.camelPlural, ctx.kebabPlural, options);
+  const run = getRunCommand();
   log.info(`
 Next steps:`);
-  log.info(`  1. Run 'pnpm db:push' to update the database`);
+  log.info(`  1. Run '${run} db:push' to update the database`);
   log.info(`  2. API available at /api/${ctx.kebabPlural}`);
 }
 function generateRoutes(camelPlural, kebabPlural, options) {
-  const basePath = path7.join(getAppPath(), "api", kebabPlural);
+  const basePath = path8.join(getAppPath(), "api", kebabPlural);
   writeFile(
-    path7.join(basePath, "route.ts"),
+    path8.join(basePath, "route.ts"),
     generateCollectionRoute(camelPlural, kebabPlural),
     options
   );
   writeFile(
-    path7.join(basePath, "[id]", "route.ts"),
+    path8.join(basePath, "[id]", "route.ts"),
     generateMemberRoute(camelPlural, kebabPlural, options),
     options
   );
@@ -1537,7 +1675,7 @@ export async function DELETE(request: Request, { params }: Params) {
 }
 
 // src/generators/destroy.ts
-import * as path8 from "path";
+import * as path9 from "path";
 import { confirm, isCancel } from "@clack/prompts";
 async function destroy(name, type, buildPath, options = {}) {
   validateModelName(name);
@@ -1563,19 +1701,756 @@ function removeFromSchema(tableName, options) {
   if (!modelExistsInSchema(tableName)) {
     return;
   }
-  const schemaPath = path8.join(getDbPath(), "schema.ts");
+  const schemaPath = path9.join(getDbPath(), "schema.ts");
   const content = readFile(schemaPath);
   const cleaned = removeModelFromSchemaContent(content, tableName);
   writeFile(schemaPath, cleaned, { force: true, dryRun: options.dryRun });
 }
 async function destroyScaffold(name, options = {}) {
-  return destroy(name, "scaffold", (ctx) => path8.join(getAppPath(), ctx.kebabPlural), options);
+  return destroy(name, "scaffold", (ctx) => path9.join(getAppPath(), ctx.kebabPlural), options);
 }
 async function destroyResource(name, options = {}) {
-  return destroy(name, "resource", (ctx) => path8.join(getAppPath(), ctx.kebabPlural), options);
+  return destroy(name, "resource", (ctx) => path9.join(getAppPath(), ctx.kebabPlural), options);
 }
 async function destroyApi(name, options = {}) {
-  return destroy(name, "API", (ctx) => path8.join(getAppPath(), "api", ctx.kebabPlural), options);
+  return destroy(name, "API", (ctx) => path9.join(getAppPath(), "api", ctx.kebabPlural), options);
+}
+
+// src/generators/init.ts
+import * as path11 from "path";
+
+// src/generators/init/prompts.ts
+import {
+  intro,
+  outro,
+  select,
+  confirm as confirm2,
+  note,
+  cancel,
+  isCancel as isCancel2,
+  log as clackLog,
+  text,
+  spinner
+} from "@clack/prompts";
+import * as path10 from "path";
+import * as fs3 from "fs";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// src/generators/init/drivers.ts
+var DRIVERS = {
+  // SQLite drivers
+  "better-sqlite3": {
+    name: "better-sqlite3",
+    driver: "better-sqlite3",
+    dialect: "sqlite",
+    package: "better-sqlite3",
+    drizzleKitDriver: "better-sqlite",
+    envVar: "DATABASE_URL",
+    envExample: "./sqlite.db",
+    hint: "Local file-based SQLite",
+    requiresUrl: false
+  },
+  libsql: {
+    name: "Turso / LibSQL",
+    driver: "libsql",
+    dialect: "sqlite",
+    package: "@libsql/client",
+    drizzleKitDriver: "turso",
+    envVar: "DATABASE_URL",
+    envExample: "libsql://your-database.turso.io",
+    hint: "Turso edge database or local LibSQL",
+    requiresUrl: true
+  },
+  "bun:sqlite": {
+    name: "Bun SQLite",
+    driver: "bun:sqlite",
+    dialect: "sqlite",
+    package: "",
+    drizzleKitDriver: "bun:sqlite",
+    envVar: "DATABASE_URL",
+    envExample: "./sqlite.db",
+    hint: "Bun's built-in SQLite driver",
+    requiresUrl: false
+  },
+  // PostgreSQL drivers
+  postgres: {
+    name: "postgres.js",
+    driver: "postgres",
+    dialect: "postgresql",
+    package: "postgres",
+    envVar: "DATABASE_URL",
+    envExample: "postgres://user:password@localhost:5432/mydb",
+    hint: "Recommended for most PostgreSQL setups",
+    requiresUrl: true
+  },
+  pg: {
+    name: "node-postgres (pg)",
+    driver: "pg",
+    dialect: "postgresql",
+    package: "pg",
+    envVar: "DATABASE_URL",
+    envExample: "postgres://user:password@localhost:5432/mydb",
+    hint: "Traditional Node.js PostgreSQL driver",
+    requiresUrl: true
+  },
+  neon: {
+    name: "Neon Serverless",
+    driver: "neon",
+    dialect: "postgresql",
+    package: "@neondatabase/serverless",
+    drizzleKitDriver: "neon-http",
+    envVar: "DATABASE_URL",
+    envExample: "postgres://user:password@ep-xxx.us-east-1.aws.neon.tech/neondb",
+    hint: "Neon serverless PostgreSQL",
+    requiresUrl: true
+  },
+  "vercel-postgres": {
+    name: "Vercel Postgres",
+    driver: "vercel-postgres",
+    dialect: "postgresql",
+    package: "@vercel/postgres",
+    drizzleKitDriver: "vercel-postgres",
+    envVar: "POSTGRES_URL",
+    envExample: "postgres://...",
+    hint: "Vercel's managed PostgreSQL",
+    requiresUrl: true
+  },
+  // MySQL drivers
+  mysql2: {
+    name: "mysql2",
+    driver: "mysql2",
+    dialect: "mysql",
+    package: "mysql2",
+    envVar: "DATABASE_URL",
+    envExample: "mysql://user:password@localhost:3306/mydb",
+    hint: "Standard MySQL/MariaDB driver",
+    requiresUrl: true
+  },
+  planetscale: {
+    name: "PlanetScale",
+    driver: "planetscale",
+    dialect: "mysql",
+    package: "@planetscale/database",
+    drizzleKitDriver: "planetscale",
+    envVar: "DATABASE_URL",
+    envExample: 'mysql://xxx:pscale_pw_xxx@aws.connect.psdb.cloud/mydb?ssl={"rejectUnauthorized":true}',
+    hint: "PlanetScale serverless MySQL",
+    requiresUrl: true
+  }
+};
+function getDriversForDialect(dialect) {
+  return Object.values(DRIVERS).filter((d) => d.dialect === dialect);
+}
+function getDriverConfig(driver) {
+  return DRIVERS[driver];
+}
+function isValidDriver(driver) {
+  return driver in DRIVERS;
+}
+function isDriverForDialect(driver, dialect) {
+  return DRIVERS[driver].dialect === dialect;
+}
+
+// src/generators/init/prompts.ts
+var execAsync = promisify(exec);
+function checkNextJsProject() {
+  const cwd = process.cwd();
+  const hasNextConfig = fs3.existsSync(path10.join(cwd, "next.config.js")) || fs3.existsSync(path10.join(cwd, "next.config.mjs")) || fs3.existsSync(path10.join(cwd, "next.config.ts"));
+  const packageJsonPath = path10.join(cwd, "package.json");
+  if (fs3.existsSync(packageJsonPath)) {
+    try {
+      const content = fs3.readFileSync(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      const hasNextDep = pkg.dependencies?.next || pkg.devDependencies?.next;
+      return hasNextConfig || !!hasNextDep;
+    } catch {
+      return hasNextConfig;
+    }
+  }
+  return hasNextConfig;
+}
+function checkExistingFiles(dbPath) {
+  const cwd = process.cwd();
+  return {
+    drizzleConfig: fileExists(path10.join(cwd, "drizzle.config.ts")),
+    dbIndex: fileExists(path10.join(cwd, dbPath, "index.ts")),
+    schema: fileExists(path10.join(cwd, dbPath, "schema.ts")),
+    envExample: fileExists(path10.join(cwd, ".env.example")),
+    dockerCompose: fileExists(path10.join(cwd, "docker-compose.yml"))
+  };
+}
+async function runInitPrompts() {
+  intro("Welcome to Brizzle - Drizzle ORM Setup Wizard");
+  if (!checkNextJsProject()) {
+    clackLog.warn("This doesn't appear to be a Next.js project. Brizzle is optimized for Next.js.");
+    const proceed = await confirm2({
+      message: "Continue anyway?",
+      initialValue: true
+    });
+    if (isCancel2(proceed) || !proceed) {
+      cancel("Setup cancelled.");
+      return null;
+    }
+  }
+  const projectConfig = detectProjectConfig();
+  const defaultDbPath = projectConfig.dbPath;
+  const dialectResult = await select({
+    message: "Select your database dialect:",
+    options: [
+      { value: "sqlite", label: "SQLite", hint: "Lightweight, file-based database" },
+      { value: "postgresql", label: "PostgreSQL", hint: "Advanced, robust database" },
+      { value: "mysql", label: "MySQL", hint: "Popular, widely-supported database" }
+    ]
+  });
+  if (isCancel2(dialectResult)) {
+    cancel("Setup cancelled.");
+    return null;
+  }
+  const dialect = dialectResult;
+  const driverOptions = getDriversForDialect(dialect).map((d) => ({
+    value: d.driver,
+    label: d.name,
+    hint: d.hint
+  }));
+  const driverResult = await select({
+    message: "Select your database driver:",
+    options: driverOptions
+  });
+  if (isCancel2(driverResult)) {
+    cancel("Setup cancelled.");
+    return null;
+  }
+  const driver = driverResult;
+  const dbPath = await text({
+    message: "Where should database files be located?",
+    placeholder: defaultDbPath,
+    defaultValue: defaultDbPath,
+    validate: (value) => {
+      if (!value) return "Path is required";
+      if (value.includes("..")) return "Path cannot contain '..'";
+      return void 0;
+    }
+  });
+  if (isCancel2(dbPath)) {
+    cancel("Setup cancelled.");
+    return null;
+  }
+  const createEnvFile = await confirm2({
+    message: "Create/update .env.example with database connection template?",
+    initialValue: true
+  });
+  if (isCancel2(createEnvFile)) {
+    cancel("Setup cancelled.");
+    return null;
+  }
+  let createDockerCompose = false;
+  if (dialect !== "sqlite") {
+    const dockerResult = await confirm2({
+      message: "Generate docker-compose.yml for local database?",
+      initialValue: false
+    });
+    if (isCancel2(dockerResult)) {
+      cancel("Setup cancelled.");
+      return null;
+    }
+    createDockerCompose = dockerResult;
+  }
+  const installDeps = await confirm2({
+    message: "Install dependencies now?",
+    initialValue: true
+  });
+  if (isCancel2(installDeps)) {
+    cancel("Setup cancelled.");
+    return null;
+  }
+  return {
+    dialect,
+    driver,
+    dbPath,
+    createEnvFile,
+    createDockerCompose,
+    installDeps
+  };
+}
+async function promptOverwrite(filePath) {
+  const result = await confirm2({
+    message: `${filePath} already exists. Overwrite?`,
+    initialValue: false
+  });
+  if (isCancel2(result)) {
+    return null;
+  }
+  return result;
+}
+async function installDependencies(options) {
+  const driverConfig = DRIVERS[options.driver];
+  const pm = detectPackageManager();
+  const packages = [];
+  if (driverConfig.package) {
+    packages.push(driverConfig.package);
+  }
+  packages.push("drizzle-orm");
+  const devPackages = ["drizzle-kit"];
+  const installCmd = pm === "npm" ? "npm install" : `${pm} add`;
+  const devFlag = pm === "npm" ? "--save-dev" : "-D";
+  const s = spinner();
+  try {
+    s.start(`Installing ${packages.join(", ")}...`);
+    await execAsync(`${installCmd} ${packages.join(" ")}`, {
+      cwd: process.cwd()
+    });
+    s.stop(`Installed ${packages.join(", ")}`);
+    s.start(`Installing ${devPackages.join(", ")} (dev)...`);
+    await execAsync(`${installCmd} ${devFlag} ${devPackages.join(" ")}`, {
+      cwd: process.cwd()
+    });
+    s.stop(`Installed ${devPackages.join(", ")}`);
+    return true;
+  } catch {
+    s.stop("Installation failed");
+    clackLog.error(
+      `Failed to install dependencies. Please run manually:
+  ${installCmd} ${packages.join(" ")}
+  ${installCmd} ${devFlag} ${devPackages.join(" ")}`
+    );
+    return false;
+  }
+}
+function addScriptsToPackageJson() {
+  const cwd = process.cwd();
+  const packageJsonPath = path10.join(cwd, "package.json");
+  if (!fs3.existsSync(packageJsonPath)) {
+    clackLog.warn("package.json not found, skipping script addition");
+    return false;
+  }
+  try {
+    const content = fs3.readFileSync(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    if (!pkg.scripts) {
+      pkg.scripts = {};
+    }
+    const scriptsToAdd = {
+      "db:generate": "drizzle-kit generate",
+      "db:migrate": "drizzle-kit migrate",
+      "db:push": "drizzle-kit push",
+      "db:studio": "drizzle-kit studio"
+    };
+    let scriptsAdded = 0;
+    for (const [name, command] of Object.entries(scriptsToAdd)) {
+      if (!pkg.scripts[name]) {
+        pkg.scripts[name] = command;
+        scriptsAdded++;
+      }
+    }
+    if (scriptsAdded > 0) {
+      fs3.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+      clackLog.info(`Added ${scriptsAdded} script(s) to package.json`);
+    }
+    return true;
+  } catch {
+    clackLog.warn("Failed to add scripts to package.json");
+    return false;
+  }
+}
+function showSummary(options, filesCreated, depsInstalled) {
+  const driverConfig = DRIVERS[options.driver];
+  if (filesCreated.length > 0) {
+    note(filesCreated.map((f) => `  ${f}`).join("\n"), "Files created");
+  }
+  if (!depsInstalled) {
+    const packages = [];
+    if (driverConfig.package) {
+      packages.push(driverConfig.package);
+    }
+    packages.push("drizzle-orm");
+    const pm = detectPackageManager();
+    const installCmd = pm === "npm" ? "npm install" : `${pm} add`;
+    const devFlag = pm === "npm" ? "--save-dev" : "-D";
+    note(
+      `${installCmd} ${packages.join(" ")}
+${installCmd} ${devFlag} drizzle-kit`,
+      "Install dependencies"
+    );
+  }
+  const nextSteps = [];
+  let step = 1;
+  if (options.createDockerCompose) {
+    nextSteps.push(`${step}. Start your database: docker compose up -d`);
+    step++;
+  }
+  if (options.createEnvFile) {
+    nextSteps.push(`${step}. Copy environment file: cp .env.example .env`);
+    step++;
+  }
+  nextSteps.push(`${step}. Set ${driverConfig.envVar} in your .env file`);
+  step++;
+  const run = getRunCommand();
+  nextSteps.push(`${step}. Scaffold your first CRUD:`);
+  nextSteps.push(`   npx brizzle scaffold post title:string body:text`);
+  step++;
+  nextSteps.push(`${step}. Generate and run migrations:`);
+  nextSteps.push(`   ${run} db:generate`);
+  nextSteps.push(`   ${run} db:migrate`);
+  note(nextSteps.join("\n"), "Next steps");
+  outro("Happy coding with Drizzle ORM!");
+}
+
+// src/generators/init/templates.ts
+function generateDrizzleConfig(options) {
+  const config = getDriverConfig(options.driver);
+  return `import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./${options.dbPath}/schema.ts",
+  out: "./${options.dbPath}/migrations",
+  dialect: "${options.dialect}",
+  dbCredentials: {
+    url: process.env.${config.envVar}!,
+  },
+});
+`;
+}
+function generateDbClient(options) {
+  switch (options.driver) {
+    case "better-sqlite3":
+      return generateBetterSqliteClient(options);
+    case "libsql":
+      return generateLibsqlClient(options);
+    case "bun:sqlite":
+      return generateBunSqliteClient(options);
+    case "postgres":
+      return generatePostgresJsClient(options);
+    case "pg":
+      return generatePgClient(options);
+    case "neon":
+      return generateNeonClient(options);
+    case "vercel-postgres":
+      return generateVercelPgClient(options);
+    case "mysql2":
+      return generateMysql2Client(options);
+    case "planetscale":
+      return generatePlanetscaleClient(options);
+    default:
+      throw new Error(`Unsupported driver: ${options.driver}`);
+  }
+}
+function generateBetterSqliteClient(options) {
+  const config = getDriverConfig(options.driver);
+  return `import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import * as schema from "./schema";
+
+const sqlite = new Database(process.env.${config.envVar} || "sqlite.db");
+
+export const db = drizzle(sqlite, { schema });
+`;
+}
+function generateLibsqlClient(options) {
+  const config = getDriverConfig(options.driver);
+  return `import { createClient } from "@libsql/client";
+import { drizzle } from "drizzle-orm/libsql";
+import * as schema from "./schema";
+
+const client = createClient({
+  url: process.env.${config.envVar}!,
+  authToken: process.env.DATABASE_AUTH_TOKEN,
+});
+
+export const db = drizzle(client, { schema });
+`;
+}
+function generateBunSqliteClient(options) {
+  const config = getDriverConfig(options.driver);
+  return `import { Database } from "bun:sqlite";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import * as schema from "./schema";
+
+const sqlite = new Database(process.env.${config.envVar} || "sqlite.db");
+
+export const db = drizzle(sqlite, { schema });
+`;
+}
+function generatePostgresJsClient(options) {
+  const config = getDriverConfig(options.driver);
+  return `import postgres from "postgres";
+import { drizzle } from "drizzle-orm/postgres-js";
+import * as schema from "./schema";
+
+const client = postgres(process.env.${config.envVar}!);
+
+export const db = drizzle(client, { schema });
+`;
+}
+function generatePgClient(options) {
+  const config = getDriverConfig(options.driver);
+  return `import { Pool } from "pg";
+import { drizzle } from "drizzle-orm/node-postgres";
+import * as schema from "./schema";
+
+const pool = new Pool({
+  connectionString: process.env.${config.envVar},
+});
+
+export const db = drizzle(pool, { schema });
+`;
+}
+function generateNeonClient(options) {
+  const config = getDriverConfig(options.driver);
+  return `import { neon } from "@neondatabase/serverless";
+import { drizzle } from "drizzle-orm/neon-http";
+import * as schema from "./schema";
+
+const sql = neon(process.env.${config.envVar}!);
+
+export const db = drizzle(sql, { schema });
+`;
+}
+function generateVercelPgClient(_options) {
+  return `import { sql } from "@vercel/postgres";
+import { drizzle } from "drizzle-orm/vercel-postgres";
+import * as schema from "./schema";
+
+export const db = drizzle(sql, { schema });
+`;
+}
+function generateMysql2Client(options) {
+  const config = getDriverConfig(options.driver);
+  return `import mysql from "mysql2/promise";
+import { drizzle } from "drizzle-orm/mysql2";
+import * as schema from "./schema";
+
+const connection = await mysql.createConnection(process.env.${config.envVar}!);
+
+export const db = drizzle(connection, { schema, mode: "default" });
+`;
+}
+function generatePlanetscaleClient(options) {
+  const config = getDriverConfig(options.driver);
+  return `import { connect } from "@planetscale/database";
+import { drizzle } from "drizzle-orm/planetscale-serverless";
+import * as schema from "./schema";
+
+const connection = connect({
+  url: process.env.${config.envVar},
+});
+
+export const db = drizzle(connection, { schema, mode: "planetscale" });
+`;
+}
+function generateSchema(dialect) {
+  const drizzleImport = getDrizzleImport(dialect);
+  const tableFunction = getTableFunction(dialect);
+  return `import { ${tableFunction} } from "${drizzleImport}";
+
+// Scaffold your first CRUD: npx brizzle scaffold post title:string body:text
+`;
+}
+function generateEnvExample(options) {
+  const config = getDriverConfig(options.driver);
+  let content = `# Database
+`;
+  if (options.createDockerCompose) {
+    if (options.dialect === "postgresql") {
+      content += `${config.envVar}="postgres://postgres:postgres@localhost:5432/myapp"
+`;
+    } else if (options.dialect === "mysql") {
+      content += `${config.envVar}="mysql://root:root@localhost:3306/myapp"
+`;
+    } else {
+      content += `${config.envVar}="${config.envExample}"
+`;
+    }
+  } else {
+    content += `${config.envVar}="${config.envExample}"
+`;
+  }
+  if (options.driver === "libsql") {
+    content += `DATABASE_AUTH_TOKEN="your-auth-token"
+`;
+  }
+  return content;
+}
+function generatePostgresDockerCompose() {
+  return `services:
+  db:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: myapp
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+volumes:
+  postgres_data:
+`;
+}
+function generateMysqlDockerCompose() {
+  return `services:
+  db:
+    image: mysql:8
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_DATABASE: myapp
+    ports:
+      - "3306:3306"
+    volumes:
+      - mysql_data:/var/lib/mysql
+
+volumes:
+  mysql_data:
+`;
+}
+function generateDockerCompose(dialect) {
+  switch (dialect) {
+    case "postgresql":
+      return generatePostgresDockerCompose();
+    case "mysql":
+      return generateMysqlDockerCompose();
+    default:
+      return null;
+  }
+}
+
+// src/generators/init.ts
+var VALID_DIALECTS = ["sqlite", "postgresql", "mysql"];
+function validateDialect(dialect) {
+  if (!VALID_DIALECTS.includes(dialect)) {
+    throw new Error(`Invalid dialect "${dialect}". Must be: ${VALID_DIALECTS.join(", ")}`);
+  }
+  return dialect;
+}
+function validateDriver(driver, dialect) {
+  if (!isValidDriver(driver)) {
+    throw new Error(`Invalid driver "${driver}".`);
+  }
+  if (!isDriverForDialect(driver, dialect)) {
+    throw new Error(`Driver "${driver}" is not compatible with dialect "${dialect}".`);
+  }
+  return driver;
+}
+async function generateInit(commandOptions = {}) {
+  let options;
+  if (commandOptions.dialect && commandOptions.driver) {
+    const dialect = validateDialect(commandOptions.dialect);
+    const driver = validateDriver(commandOptions.driver, dialect);
+    const projectConfig = detectProjectConfig();
+    options = {
+      dialect,
+      driver,
+      dbPath: projectConfig.dbPath,
+      createEnvFile: true,
+      createDockerCompose: false,
+      installDeps: commandOptions.install !== false,
+      force: commandOptions.force,
+      dryRun: commandOptions.dryRun
+    };
+  } else if (commandOptions.dialect || commandOptions.driver) {
+    throw new Error("Both --dialect and --driver must be provided for non-interactive mode.");
+  } else {
+    const promptResult = await runInitPrompts();
+    if (!promptResult) {
+      return;
+    }
+    options = {
+      ...promptResult,
+      force: commandOptions.force,
+      dryRun: commandOptions.dryRun
+    };
+  }
+  const filesCreated = await createFiles(options);
+  if (options.dryRun) {
+    log.info("\nDry run complete. No files were written.\n");
+    return;
+  }
+  if (filesCreated.length === 0) {
+    log.info("\nNo files were created. All files already exist.\n");
+    return;
+  }
+  addScriptsToPackageJson();
+  let depsInstalled = false;
+  if (options.installDeps) {
+    depsInstalled = await installDependencies(options);
+  }
+  showSummary(options, filesCreated, depsInstalled);
+}
+async function createFiles(options) {
+  const cwd = process.cwd();
+  const filesCreated = [];
+  const existing = checkExistingFiles(options.dbPath);
+  const drizzleConfigPath = path11.join(cwd, "drizzle.config.ts");
+  if (await shouldWriteFile(drizzleConfigPath, existing.drizzleConfig, options)) {
+    const content = generateDrizzleConfig(options);
+    if (writeFile(drizzleConfigPath, content, { force: true, dryRun: options.dryRun })) {
+      filesCreated.push("drizzle.config.ts");
+    }
+  }
+  const dbIndexPath = path11.join(cwd, options.dbPath, "index.ts");
+  if (await shouldWriteFile(dbIndexPath, existing.dbIndex, options)) {
+    const content = generateDbClient(options);
+    if (writeFile(dbIndexPath, content, { force: true, dryRun: options.dryRun })) {
+      filesCreated.push(`${options.dbPath}/index.ts`);
+    }
+  }
+  const schemaPath = path11.join(cwd, options.dbPath, "schema.ts");
+  if (await shouldWriteFile(schemaPath, existing.schema, options)) {
+    const content = generateSchema(options.dialect);
+    if (writeFile(schemaPath, content, { force: true, dryRun: options.dryRun })) {
+      filesCreated.push(`${options.dbPath}/schema.ts`);
+    }
+  }
+  if (options.createEnvFile) {
+    const envExamplePath = path11.join(cwd, ".env.example");
+    const newEnvContent = generateEnvExample(options);
+    const config = getDriverConfig(options.driver);
+    if (existing.envExample && !options.force) {
+      const existingContent = readFile(envExamplePath);
+      if (!existingContent.includes(config.envVar)) {
+        const mergedContent = existingContent.trimEnd() + "\n\n" + newEnvContent;
+        if (writeFile(envExamplePath, mergedContent, { force: true, dryRun: options.dryRun })) {
+          filesCreated.push(".env.example (updated)");
+        }
+      } else {
+        log.skip(envExamplePath);
+      }
+    } else if (await shouldWriteFile(envExamplePath, existing.envExample, options)) {
+      if (writeFile(envExamplePath, newEnvContent, { force: true, dryRun: options.dryRun })) {
+        filesCreated.push(".env.example");
+      }
+    }
+  }
+  if (options.createDockerCompose) {
+    const dockerComposePath = path11.join(cwd, "docker-compose.yml");
+    if (await shouldWriteFile(dockerComposePath, existing.dockerCompose, options)) {
+      const content = generateDockerCompose(options.dialect);
+      if (content) {
+        if (writeFile(dockerComposePath, content, { force: true, dryRun: options.dryRun })) {
+          filesCreated.push("docker-compose.yml");
+        }
+      }
+    }
+  }
+  return filesCreated;
+}
+async function shouldWriteFile(filePath, exists, options) {
+  if (!exists) {
+    return true;
+  }
+  if (options.force || options.dryRun) {
+    return true;
+  }
+  const result = await promptOverwrite(path11.basename(filePath));
+  if (result === null) {
+    log.info("Aborted.");
+    process.exit(0);
+  }
+  if (!result) {
+    log.skip(filePath);
+  }
+  return result;
 }
 
 // src/index.ts
@@ -1679,7 +2554,12 @@ program.command("destroy <type> <name>").alias("d").description(
     brizzle d api product --dry-run`
 ).option("-f, --force", "Skip confirmation prompt").option("-n, --dry-run", "Preview changes without deleting files").action(async (type, name, opts) => {
   try {
-    switch (type) {
+    const validTypes = ["scaffold", "resource", "api"];
+    if (!validTypes.includes(type)) {
+      throw new Error(`Unknown type "${type}". Use: scaffold, resource, or api`);
+    }
+    const destroyType = type;
+    switch (destroyType) {
       case "scaffold":
         await destroyScaffold(name, opts);
         break;
@@ -1689,8 +2569,6 @@ program.command("destroy <type> <name>").alias("d").description(
       case "api":
         await destroyApi(name, opts);
         break;
-      default:
-        throw new Error(`Unknown type "${type}". Use: scaffold, resource, or api`);
     }
   } catch (error) {
     handleError(error);
@@ -1700,7 +2578,9 @@ program.command("config").description("Show detected project configuration").act
   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(
+    `  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}/`);
@@ -1711,4 +2591,30 @@ program.command("config").description("Show detected project configuration").act
   console.log(`  Schema: ${config.alias}/${config.dbPath.replace(/^src\//, "")}/schema`);
   console.log();
 });
+program.command("init").description(
+  `Initialize Drizzle ORM in your Next.js project
+
+  Interactive setup wizard that configures:
+    - Database dialect (SQLite, PostgreSQL, MySQL)
+    - Database driver selection
+    - drizzle.config.ts
+    - Database client export (db/index.ts)
+    - Schema file (db/schema.ts)
+    - Environment variables template
+
+  Examples:
+    brizzle init
+    brizzle init --dry-run
+    brizzle init --dialect postgresql --driver postgres
+    brizzle init --dialect sqlite --driver better-sqlite3 --no-install`
+).option("-f, --force", "Overwrite existing files without prompting").option("-n, --dry-run", "Preview changes without writing files").option(
+  "-d, --dialect <dialect>",
+  "Database dialect for non-interactive mode (sqlite, postgresql, mysql)"
+).option("--driver <driver>", "Database driver for non-interactive mode").option("--no-install", "Skip automatic dependency installation").action(async (opts) => {
+  try {
+    await generateInit(opts);
+  } catch (error) {
+    handleError(error);
+  }
+});
 program.parse();