brizzle 0.2.6 → 0.2.8

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());
 }
@@ -163,25 +164,10 @@ 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);
@@ -330,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.`
+      );
+    }
   }
 }
 
@@ -501,6 +506,24 @@ function getTimestampColumns(dialect, noTimestamps = false) {
     .$defaultFn(() => new Date())`;
   }
 }
+function extractImportsFromSchema(content) {
+  const importMatch = content.match(/import\s*\{([^}]+)\}\s*from\s*["']drizzle-orm\/[^"']+["']/);
+  if (!importMatch) {
+    return [];
+  }
+  return importMatch[1].split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function updateSchemaImports(content, newImports, dialect) {
+  const existingImports = extractImportsFromSchema(content);
+  const mergedImports = Array.from(/* @__PURE__ */ new Set([...existingImports, ...newImports]));
+  const drizzleImport = getDrizzleImport(dialect);
+  const newImportLine = `import { ${mergedImports.join(", ")} } from "${drizzleImport}";`;
+  const importRegex = /import\s*\{[^}]+\}\s*from\s*["']drizzle-orm\/[^"']+["'];?/;
+  if (importRegex.test(content)) {
+    return content.replace(importRegex, newImportLine);
+  }
+  return newImportLine + "\n" + content;
+}
 function getRequiredImports(fields, dialect, options = {}) {
   const types = /* @__PURE__ */ new Set();
   types.add(getTableFunction(dialect));
@@ -542,7 +565,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);
@@ -596,6 +619,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)) {
@@ -603,10 +629,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 = {}) {
@@ -620,15 +682,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 = {}) {
@@ -660,7 +720,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);
@@ -672,7 +732,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);
@@ -681,8 +741,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;
@@ -706,6 +766,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);
@@ -722,9 +800,21 @@ function generateEnumField(field, columnName, dialect) {
 }
 function appendToSchema(schemaPath, modelName, tableName, fields, dialect, options) {
   const existingContent = readFile(schemaPath);
+  const newImports = getRequiredImports(fields, dialect, options);
+  const updatedContent = updateSchemaImports(existingContent, newImports, dialect);
   const enumDefinitions = generateEnumDefinitions(fields, dialect);
   const tableDefinition = generateTableDefinition(modelName, tableName, fields, dialect, options);
-  const newContent = existingContent + enumDefinitions + "\n" + tableDefinition + "\n";
+  const newContent = updatedContent + 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 newImports = getRequiredImports(fields, dialect, options);
+  const updatedContent = updateSchemaImports(cleanedContent, newImports, dialect);
+  const enumDefinitions = generateEnumDefinitions(fields, dialect);
+  const tableDefinition = generateTableDefinition(modelName, tableName, fields, dialect, options);
+  const newContent = updatedContent.trimEnd() + "\n" + enumDefinitions + "\n" + tableDefinition + "\n";
   writeFile(schemaPath, newContent, { force: true, dryRun: options.dryRun });
 }
 
@@ -996,11 +1086,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>
   );
@@ -1448,28 +1538,44 @@ export async function DELETE(request: Request, { params }: Params) {
 
 // src/generators/destroy.ts
 import * as path8 from "path";
-function destroy(name, type, buildPath, 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 ${type} ${ctx.pascalName}...
 `);
   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 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 destroyScaffold(name, options = {}) {
-  destroy(name, "scaffold", (ctx) => path8.join(getAppPath(), ctx.kebabPlural), options);
+async function destroyScaffold(name, options = {}) {
+  return destroy(name, "scaffold", (ctx) => path8.join(getAppPath(), ctx.kebabPlural), options);
 }
-function destroyResource(name, options = {}) {
-  destroy(name, "resource", (ctx) => path8.join(getAppPath(), ctx.kebabPlural), options);
+async function destroyResource(name, options = {}) {
+  return destroy(name, "resource", (ctx) => path8.join(getAppPath(), ctx.kebabPlural), options);
 }
-function destroyApi(name, options = {}) {
-  destroy(name, "API", (ctx) => path8.join(getAppPath(), "api", ctx.kebabPlural), options);
+async function destroyApi(name, options = {}) {
+  return destroy(name, "API", (ctx) => path8.join(getAppPath(), "api", ctx.kebabPlural), options);
 }
 
 // src/index.ts
@@ -1571,17 +1677,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.6",
+  "version": "0.2.8",
   "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"