brizzle 0.2.5 → 0.2.7

package/dist/index.js

@@ -146,6 +146,7 @@ var log = {
 };
 
 // src/lib/strings.ts
+import pluralizeLib from "pluralize";
 function toPascalCase(str) {
   return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
 }
@@ -159,26 +160,14 @@ function toSnakeCase(str) {
 function toKebabCase(str) {
   return toSnakeCase(str).replace(/_/g, "-");
 }
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").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";
+  return pluralizeLib.plural(str);
 }
 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;
+  return pluralizeLib.singular(str);
 }
 function createModelContext(name) {
   const singularName = singularize(name);
@@ -200,6 +189,82 @@ function createModelContext(name) {
 }
 
 // src/lib/validation.ts
+var SQL_RESERVED_WORDS = [
+  // SQL keywords
+  "select",
+  "from",
+  "where",
+  "insert",
+  "update",
+  "delete",
+  "drop",
+  "create",
+  "alter",
+  "index",
+  "table",
+  "column",
+  "database",
+  "schema",
+  "and",
+  "or",
+  "not",
+  "null",
+  "true",
+  "false",
+  "order",
+  "by",
+  "group",
+  "having",
+  "limit",
+  "offset",
+  "join",
+  "left",
+  "right",
+  "inner",
+  "outer",
+  "on",
+  "as",
+  "in",
+  "between",
+  "like",
+  "is",
+  "case",
+  "when",
+  "then",
+  "else",
+  "end",
+  "exists",
+  "distinct",
+  "all",
+  "any",
+  "union",
+  "intersect",
+  "except",
+  "primary",
+  "foreign",
+  "key",
+  "references",
+  "unique",
+  "default",
+  "check",
+  "constraint",
+  // Common type names that might conflict
+  "int",
+  "integer",
+  "float",
+  "double",
+  "decimal",
+  "numeric",
+  "boolean",
+  "bool",
+  "text",
+  "varchar",
+  "char",
+  "date",
+  "time",
+  "timestamp",
+  "datetime"
+];
 function validateModelName(name) {
   if (!name) {
     throw new Error("Model name is required");
@@ -232,6 +297,11 @@ function validateFieldDefinition(fieldDef) {
       `Invalid field name "${name}". Must be camelCase (start with lowercase letter).`
     );
   }
+  if (SQL_RESERVED_WORDS.includes(name.toLowerCase())) {
+    throw new Error(
+      `Field name "${name}" is a SQL reserved word. Consider renaming to "${name}Value" or "${name}Field".`
+    );
+  }
   if (type && !type.startsWith("references") && type !== "enum" && type !== "unique") {
     if (!VALID_FIELD_TYPES.includes(type)) {
       throw new Error(
@@ -246,6 +316,25 @@ function validateFieldDefinition(fieldDef) {
         `Enum field "${name}" requires values. Example: ${name}:enum:draft,published,archived`
       );
     }
+    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.`
+        );
+      }
+      if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(value)) {
+        throw new Error(
+          `Invalid enum value "${value}" for field "${name}". Values must start with a letter and contain only letters, numbers, underscores, or hyphens.`
+        );
+      }
+    }
+    const unique = new Set(values);
+    if (unique.size !== values.length) {
+      throw new Error(
+        `Enum field "${name}" has duplicate values.`
+      );
+    }
   }
 }
 
@@ -458,7 +547,7 @@ function getRequiredImports(fields, dialect, options = {}) {
     const baseType = drizzleTypeDef.split("(")[0];
     types.add(baseType);
   }
-  if (dialect !== "mysql") {
+  if (dialect === "sqlite" && hasEnums) {
     types.add("text");
   }
   return Array.from(types);
@@ -512,6 +601,9 @@ function fileExists(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)) {
@@ -519,10 +611,46 @@ function modelExistsInSchema(tableName) {
   }
   const content = fs2.readFileSync(schemaPath, "utf-8");
   const pattern = new RegExp(
-    `(?:sqliteTable|pgTable|mysqlTable)\\s*\\(\\s*["']${tableName}["']`
+    `(?: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/generators/model.ts
 function generateModel(name, fieldArgs, options = {}) {
@@ -536,15 +664,13 @@ function generateModel(name, fieldArgs, options = {}) {
     );
   }
   const schemaPath = path4.join(getDbPath(), "schema.ts");
-  if (fileExists(schemaPath) && !modelExistsInSchema(ctx.tableName)) {
-    appendToSchema(schemaPath, ctx.camelPlural, ctx.tableName, fields, dialect, options);
-  } else if (!fileExists(schemaPath)) {
+  if (!fileExists(schemaPath)) {
     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);
   } else {
-    throw new Error(
-      `Cannot regenerate model "${ctx.pascalName}" - manual removal from schema required.`
-    );
+    appendToSchema(schemaPath, ctx.camelPlural, ctx.tableName, fields, dialect, options);
   }
 }
 function generateSchemaContent(modelName, tableName, fields, dialect, options = {}) {
@@ -567,7 +693,7 @@ function generateEnumDefinitions(fields, dialect) {
   }
   return enumFields.map((field) => {
     const enumName = `${field.name}Enum`;
-    const values = field.enumValues.map((v) => `"${v}"`).join(", ");
+    const values = field.enumValues.map((v) => `"${escapeString(v)}"`).join(", ");
     return `
 export const ${enumName} = pgEnum("${toSnakeCase(field.name)}", [${values}]);`;
   }).join("\n");
@@ -576,7 +702,7 @@ 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 fieldDefinitions = generateFieldDefinitions(fields, dialect, options);
   const lines = [`  ${idColumn},`];
   if (fieldDefinitions) {
     lines.push(fieldDefinitions);
@@ -588,7 +714,7 @@ function generateTableDefinition(modelName, tableName, fields, dialect, options
 ${lines.join("\n")}
 });`;
 }
-function generateFieldDefinitions(fields, dialect) {
+function generateFieldDefinitions(fields, dialect, options = {}) {
   return fields.map((field) => {
     const columnName = toSnakeCase(field.name);
     const modifiers = getFieldModifiers(field);
@@ -597,8 +723,8 @@ function generateFieldDefinitions(fields, 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},`;
+      const refTarget = `${toCamelCase(pluralize(field.referenceTo))}.id`;
+      return `  ${field.name}: ${getReferenceType(dialect, columnName, options.uuid)}.references(() => ${refTarget})${modifiers},`;
     }
     if (dialect === "mysql" && drizzleTypeDef === "varchar") {
       const length = field.type === "uuid" ? 36 : 255;
@@ -622,6 +748,24 @@ function getFieldModifiers(field) {
   }
   return modifiers.join("");
 }
+function getReferenceType(dialect, columnName, useUuid = false) {
+  if (useUuid) {
+    switch (dialect) {
+      case "postgresql":
+        return `uuid("${columnName}")`;
+      case "mysql":
+        return `varchar("${columnName}", { length: 36 })`;
+      default:
+        return `text("${columnName}")`;
+    }
+  }
+  switch (dialect) {
+    case "mysql":
+      return `int("${columnName}")`;
+    default:
+      return `integer("${columnName}")`;
+  }
+}
 function generateEnumField(field, columnName, dialect) {
   const values = field.enumValues;
   const modifiers = getFieldModifiers(field);
@@ -629,10 +773,10 @@ function generateEnumField(field, columnName, dialect) {
     case "postgresql":
       return `  ${field.name}: ${field.name}Enum("${columnName}")${modifiers},`;
     case "mysql":
-      const mysqlValues = values.map((v) => `"${v}"`).join(", ");
+      const mysqlValues = values.map((v) => `"${escapeString(v)}"`).join(", ");
       return `  ${field.name}: mysqlEnum("${columnName}", [${mysqlValues}])${modifiers},`;
     default:
-      const sqliteValues = values.map((v) => `"${v}"`).join(", ");
+      const sqliteValues = values.map((v) => `"${escapeString(v)}"`).join(", ");
       return `  ${field.name}: text("${columnName}", { enum: [${sqliteValues}] })${modifiers},`;
   }
 }
@@ -643,6 +787,14 @@ function appendToSchema(schemaPath, modelName, tableName, fields, dialect, optio
   const newContent = existingContent + enumDefinitions + "\n" + tableDefinition + "\n";
   writeFile(schemaPath, newContent, { force: true, dryRun: options.dryRun });
 }
+function replaceInSchema(schemaPath, modelName, tableName, fields, dialect, options) {
+  const existingContent = readFile(schemaPath);
+  const cleanedContent = removeModelFromSchemaContent(existingContent, tableName);
+  const enumDefinitions = generateEnumDefinitions(fields, dialect);
+  const tableDefinition = generateTableDefinition(modelName, tableName, fields, dialect, options);
+  const newContent = cleanedContent.trimEnd() + "\n" + enumDefinitions + "\n" + tableDefinition + "\n";
+  writeFile(schemaPath, newContent, { force: true, dryRun: options.dryRun });
+}
 
 // src/generators/actions.ts
 import * as path5 from "path";
@@ -682,12 +834,15 @@ export async function get${pascalName}(id: ${idType}) {
     .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];
 }
 
@@ -700,12 +855,15 @@ export async function update${pascalName}(
     .set({ ...data, updatedAt: new Date() })
     .where(eq(${camelPlural}.id, id))
     .returning();
+
   revalidatePath("/${kebabPlural}");
+
   return result[0];
 }
 
 export async function delete${pascalName}(id: ${idType}) {
   await db.delete(${camelPlural}).where(eq(${camelPlural}.id, id));
+
   revalidatePath("/${kebabPlural}");
 }
 `;
@@ -821,9 +979,11 @@ 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}");
   }
 
@@ -856,9 +1016,11 @@ ${fields.map((f) => generateFormField(f, camelName)).join("\n\n")}
 }
 function generateShowPage(pascalName, _pascalPlural, camelName, kebabPlural, fields, options = {}) {
   const idHandling = options.uuid ? `const ${camelName} = await get${pascalName}(id);` : `const numericId = Number(id);
+
   if (isNaN(numericId)) {
     notFound();
   }
+
   const ${camelName} = await get${pascalName}(numericId);`;
   return `import { notFound } from "next/navigation";
 import Link from "next/link";
@@ -902,11 +1064,11 @@ ${fields.map(
           <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")}
+  ).join("\n")}${options.noTimestamps ? "" : `
         <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>
+        </div>`}
       </dl>
     </div>
   );
@@ -915,9 +1077,11 @@ ${fields.map(
 }
 function generateEditPage(pascalName, camelName, kebabPlural, fields, options = {}) {
   const idHandling = options.uuid ? `const ${camelName} = await get${pascalName}(id);` : `const numericId = Number(id);
+
   if (isNaN(numericId)) {
     notFound();
   }
+
   const ${camelName} = await get${pascalName}(numericId);`;
   const updateId = options.uuid ? "id" : "numericId";
   return `import { notFound, redirect } from "next/navigation";
@@ -938,9 +1102,11 @@ export default async function Edit${pascalName}Page({
 
   async function handleUpdate(formData: FormData) {
     "use server";
+
     await update${pascalName}(${updateId}, {
 ${fields.map((f) => `      ${f.name}: ${formDataValue(f)},`).join("\n")}
     });
+
     redirect("/${kebabPlural}");
   }
 
@@ -971,17 +1137,20 @@ ${fields.map((f) => generateFormField(f, camelName, true)).join("\n\n")}
 }
 `;
 }
-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>
+function createFieldContext(field, camelName, withDefault) {
+  return {
+    field,
+    label: toPascalCase(field.name),
+    optionalLabel: field.nullable ? ` <span className="text-gray-400">(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-gray-700">
             ${label}${optionalLabel}
           </label>
@@ -989,13 +1158,14 @@ function generateFormField(field, camelName, withDefault = false) {
             id="${field.name}"
             name="${field.name}"
             rows={${rows}}
-            className="${inputClasses} resize-none"${defaultValue}${placeholder}${required}
+            className="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 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">
+}
+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}"
@@ -1006,38 +1176,27 @@ function generateFormField(field, camelName, withDefault = false) {
             ${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>
+}
+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-gray-700">
             ${label}${optionalLabel}
           </label>
           <input
-            type="number"
-            step="${step}"
+            type="number"${stepAttr}
             id="${field.name}"
             name="${field.name}"
-            className="${inputClasses}"${defaultValue}${required}
+            className="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"${defaultValue}${required}
           />
         </div>`;
-  }
-  if (field.type === "date") {
-    const dateDefault = withDefault ? ` defaultValue={${camelName}.${field.name}?.toISOString().split("T")[0]}` : "";
-    return `        <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-gray-700">
             ${label}${optionalLabel}
           </label>
@@ -1045,13 +1204,14 @@ function generateFormField(field, camelName, withDefault = false) {
             type="date"
             id="${field.name}"
             name="${field.name}"
-            className="${inputClasses}"${dateDefault}${required}
+            className="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"${dateDefault}${required}
           />
         </div>`;
-  }
-  if (field.type === "datetime" || field.type === "timestamp") {
-    const dateDefault = withDefault ? ` defaultValue={${camelName}.${field.name}?.toISOString().slice(0, 16)}` : "";
-    return `        <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-gray-700">
             ${label}${optionalLabel}
           </label>
@@ -1059,25 +1219,28 @@ function generateFormField(field, camelName, withDefault = false) {
             type="datetime-local"
             id="${field.name}"
             name="${field.name}"
-            className="${inputClasses}"${dateDefault}${required}
+            className="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"${dateDefault}${required}
           />
         </div>`;
-  }
-  if (field.isEnum && field.enumValues) {
-    const options = field.enumValues.map((v) => `            <option value="${v}">${toPascalCase(v)}</option>`).join("\n");
-    return `        <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-gray-700">
             ${label}${optionalLabel}
           </label>
           <select
             id="${field.name}"
             name="${field.name}"
-            className="${selectClasses}"${defaultValue}${required}
+            className="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"${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-gray-700">
             ${label}${optionalLabel}
@@ -1086,14 +1249,46 @@ ${options}
             type="text"
             id="${field.name}"
             name="${field.name}"
-            className="${inputClasses}"${defaultValue}${required}
+            className="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"${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`;
     }
@@ -1120,6 +1315,9 @@ function formDataValue(field) {
   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})`;
   }
@@ -1318,47 +1516,44 @@ export async function DELETE(request: Request, { params }: Params) {
 
 // src/generators/destroy.ts
 import * as path8 from "path";
-function destroyScaffold(name, options = {}) {
+import { confirm, isCancel } from "@clack/prompts";
+async function destroy(name, type, buildPath, options = {}) {
   validateModelName(name);
   const ctx = createModelContext(name);
-  const config = detectProjectConfig();
   const prefix = options.dryRun ? "[dry-run] " : "";
   log.info(`
-${prefix}Destroying scaffold ${ctx.pascalName}...
+${prefix}Destroying ${type} ${ctx.pascalName}...
 `);
-  const basePath = path8.join(getAppPath(), ctx.kebabPlural);
+  const basePath = buildPath(ctx);
+  if (!options.dryRun && !options.force && fileExists(basePath)) {
+    const confirmed = await confirm({
+      message: `Delete ${basePath}?`
+    });
+    if (isCancel(confirmed) || !confirmed) {
+      log.info("Aborted.");
+      return;
+    }
+  }
   deleteDirectory(basePath, options);
-  log.info(`
-Note: Schema in ${config.dbPath}/schema.ts was not modified.`);
-  log.info(`      Remove the table definition manually if needed.`);
+  removeFromSchema(ctx.tableName, options);
 }
-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 = path8.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 removeFromSchema(tableName, options) {
+  if (!modelExistsInSchema(tableName)) {
+    return;
+  }
+  const schemaPath = path8.join(getDbPath(), "schema.ts");
+  const content = readFile(schemaPath);
+  const cleaned = removeModelFromSchemaContent(content, tableName);
+  writeFile(schemaPath, cleaned, { force: true, dryRun: options.dryRun });
 }
-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 = path8.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.`);
+async function destroyScaffold(name, options = {}) {
+  return destroy(name, "scaffold", (ctx) => path8.join(getAppPath(), ctx.kebabPlural), options);
+}
+async function destroyResource(name, options = {}) {
+  return destroy(name, "resource", (ctx) => path8.join(getAppPath(), ctx.kebabPlural), options);
+}
+async function destroyApi(name, options = {}) {
+  return destroy(name, "API", (ctx) => path8.join(getAppPath(), "api", ctx.kebabPlural), options);
 }
 
 // src/index.ts
@@ -1460,17 +1655,17 @@ program.command("destroy <type> <name>").alias("d").description(
   Examples:
     brizzle destroy scaffold post
     brizzle d api product --dry-run`
-).option("-n, --dry-run", "Preview changes without deleting files").action((type, name, opts) => {
+).option("-f, --force", "Skip confirmation prompt").option("-n, --dry-run", "Preview changes without deleting files").action(async (type, name, opts) => {
   try {
     switch (type) {
       case "scaffold":
-        destroyScaffold(name, opts);
+        await destroyScaffold(name, opts);
         break;
       case "resource":
-        destroyResource(name, opts);
+        await destroyResource(name, opts);
         break;
       case "api":
-        destroyApi(name, opts);
+        await destroyApi(name, opts);
         break;
       default:
         throw new Error(`Unknown type "${type}". Use: scaffold, resource, or api`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brizzle",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Rails-like generators for Next.js + Drizzle ORM projects",
   "type": "module",
   "bin": {
@@ -50,10 +50,12 @@
   "homepage": "https://github.com/mantaskaveckas/brizzle#readme",
   "dependencies": {
     "@clack/prompts": "^0.10.0",
-    "commander": "^14.0.2"
+    "commander": "^14.0.2",
+    "pluralize": "^8.0.0"
   },
   "devDependencies": {
     "@types/node": "^20",
+    "@types/pluralize": "^0.0.33",
     "tsup": "^8",
     "typescript": "^5",
     "vitest": "^4"