brizzle 0.2.4 → 0.2.6

package/README.md

@@ -6,9 +6,10 @@
 
 <p align="center">
   <a href="https://github.com/mantaskaveckas/brizzle/actions/workflows/ci.yml"><img src="https://github.com/mantaskaveckas/brizzle/actions/workflows/ci.yml/badge.svg?branch=main" alt="CI"></a>
-[![npm version](https://img.shields.io/npm/v/brizzle)](https://www.npmjs.com/package/brizzle)
-[![npm downloads](https://img.shields.io/npm/dm/brizzle)](https://www.npmjs.com/package/brizzle)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+  <a href="https://www.npmjs.com/package/brizzle"><img src="https://img.shields.io/npm/v/brizzle" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/brizzle"><img src="https://img.shields.io/npm/dm/brizzle" alt="npm downloads"></a>
+  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
+</p>
 
 Rails-like generators for Next.js + Drizzle ORM projects. Generate models, server actions, CRUD pages, and API routes with a single command.
 

package/dist/index.js

@@ -159,6 +159,9 @@ 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";
@@ -200,6 +203,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 +311,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(
@@ -567,7 +651,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");
@@ -629,10 +713,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},`;
   }
 }
@@ -682,12 +766,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 +787,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 +911,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 +948,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";
@@ -915,9 +1009,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 +1034,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 +1069,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 +1090,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 +1108,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 +1136,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 +1151,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 +1181,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 +1247,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 +1448,28 @@ export async function DELETE(request: Request, { params }: Params) {
 
 // src/generators/destroy.ts
 import * as path8 from "path";
-function destroyScaffold(name, options = {}) {
+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);
   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 destroyScaffold(name, options = {}) {
+  destroy(name, "scaffold", (ctx) => path8.join(getAppPath(), ctx.kebabPlural), 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.`);
+  destroy(name, "resource", (ctx) => path8.join(getAppPath(), ctx.kebabPlural), options);
 }
 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.`);
+  destroy(name, "API", (ctx) => path8.join(getAppPath(), "api", ctx.kebabPlural), options);
 }
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brizzle",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Rails-like generators for Next.js + Drizzle ORM projects",
   "type": "module",
   "bin": {