mutano 2.1.0 → 2.2.0

package/dist/main.d.ts

@@ -7,9 +7,8 @@ export interface GenerateContentParams {
     isCamelCase: boolean;
     enumDeclarations: Record<string, string[]>;
     defaultZodHeader: string;
-    defaultKyselyHeader: string;
 }
-export declare function generateContent({ table, describes, config, destination, isCamelCase, enumDeclarations, defaultZodHeader, defaultKyselyHeader, }: GenerateContentParams): string;
+export declare function generateContent({ table, describes, config, destination, isCamelCase, enumDeclarations, defaultZodHeader, }: GenerateContentParams): string;
 export declare const defaultKyselyHeader = "import { Generated, ColumnType, Selectable, Insertable, Updateable } from 'kysely';\n\n";
 export declare const defaultZodHeader = "import { z } from 'zod';\n\n";
 export declare function generate(config: Config): Promise<string[] | Record<string, string>>;
@@ -46,8 +45,7 @@ export type Destination = {
     type: 'kysely';
     header?: string;
     schemaName?: string;
-    folder?: string;
-    suffix?: string;
+    outFile?: string;
 };
 export interface Config {
     origin: {

package/dist/main.js

@@ -199,10 +199,10 @@ function getType(op, desc, config, destination, tableName) {
       if (schemaType === "mysql") {
         const matches = Type.match(enumRegex);
         if (matches?.[1]) {
-          enumValues = matches[1].split(",").map((v) => v.trim());
+          enumValues = matches[1].split(",").map((v) => v.trim()).sort();
         }
       } else if (EnumOptions && EnumOptions.length > 0) {
-        enumValues = EnumOptions.map((e) => `'${e}'`);
+        enumValues = EnumOptions.map((e) => `'${e}'`).sort();
       }
       if (enumValues.length === 0) {
         return isNull ? "string | null" : "string";
@@ -303,7 +303,16 @@ function getType(op, desc, config, destination, tableName) {
     return field.join(".");
   };
   const generateEnumLikeField = () => {
-    const value = schemaType === "mysql" ? Type.replace("enum(", "").replace(")", "").replace(/,/g, ",") : EnumOptions?.map((e) => `'${e}'`).join(",");
+    let enumValues = [];
+    if (schemaType === "mysql") {
+      const matches = Type.match(enumRegex);
+      if (matches?.[1]) {
+        enumValues = matches[1].split(",").map((v) => v.trim()).sort();
+      }
+    } else if (EnumOptions && EnumOptions.length > 0) {
+      enumValues = [...EnumOptions].sort().map((e) => `'${e}'`);
+    }
+    const value = enumValues.join(",");
     const field = [`z.enum([${value}])`];
     if (isNull) field.push(nullable);
     else if (hasDefaultValue || !hasDefaultValue && isGenerated)
@@ -327,35 +336,16 @@ function generateContent({
   destination,
   isCamelCase,
   enumDeclarations: enumDeclarations2,
-  defaultZodHeader: defaultZodHeader2,
-  defaultKyselyHeader: defaultKyselyHeader2
+  defaultZodHeader: defaultZodHeader2
 }) {
   let content = "";
+  const schemaType = config.origin.type;
   if (destination.type === "kysely") {
-    const header = destination.header;
-    const schemaName = destination.schemaName || "DB";
-    content = header ? `${header}
-
-` : defaultKyselyHeader2;
-    content += `// JSON type definitions
-export type Json = ColumnType<JsonValue, string, string>;
-
-export type JsonArray = JsonValue[];
-
-export type JsonObject = {
-  [x: string]: JsonValue | undefined;
-};
-
-export type JsonPrimitive = boolean | number | string | null;
-
-export type JsonValue = JsonArray | JsonObject | JsonPrimitive;
-
-`;
     content += `// Kysely type definitions for ${table}
 `;
     content += `
 // This interface defines the structure of the '${table}' table
-export interface ${camelCase(table, { pascalCase: true })}Table {`;
+export interface ${camelCase(table, { pascalCase: true })} {`;
     for (const desc of describes) {
       const field = isCamelCase ? camelCase(desc.Field) : desc.Field;
       const type = getType("table", desc, config, destination, table);
@@ -365,9 +355,13 @@ export interface ${camelCase(table, { pascalCase: true })}Table {`;
         const isDefaultGenerated = desc.Extra.toLowerCase().includes("default_generated");
         const isNullable = desc.Null === "YES";
         const isJsonField = desc.Type.toLowerCase().includes("json");
+        const hasDefaultValue = desc.Default !== null;
+        const isEnum = schemaType !== "sqlite" && enumTypes[schemaType].includes(
+          schemaType === "mysql" ? desc.Type.split("(")[0].split(" ")[0] : desc.Type
+        );
         if (isJsonField) {
           kyselyType = "Json";
-        } else if (isAutoIncrement || isDefaultGenerated) {
+        } else if (isAutoIncrement || isDefaultGenerated || isEnum && hasDefaultValue) {
           kyselyType = `Generated<${kyselyType}>`;
         }
         if (isNullable && !isJsonField) {
@@ -382,15 +376,10 @@ export interface ${camelCase(table, { pascalCase: true })}Table {`;
     content = `${content}
 }
 
-// Define the database interface
-export interface ${schemaName} {
-  ${table}: ${camelCase(table, { pascalCase: true })}Table;
-}
-
-// Use these types for inserting, selecting and updating the table
-export type ${camelCase(table, { pascalCase: true })} = Selectable<${camelCase(table, { pascalCase: true })}Table>;
-export type New${camelCase(table, { pascalCase: true })} = Insertable<${camelCase(table, { pascalCase: true })}Table>;
-export type ${camelCase(table, { pascalCase: true })}Update = Updateable<${camelCase(table, { pascalCase: true })}Table>;
+// Helper types for ${table}
+export type Selectable${camelCase(table, { pascalCase: true })} = Selectable<${camelCase(table, { pascalCase: true })}>;
+export type Insertable${camelCase(table, { pascalCase: true })} = Insertable<${camelCase(table, { pascalCase: true })}>;
+export type Updateable${camelCase(table, { pascalCase: true })} = Updateable<${camelCase(table, { pascalCase: true })}>;
 `;
   } else if (destination.type === "ts") {
     const modelType = destination.modelType || "interface";
@@ -553,6 +542,7 @@ async function generate(config) {
   let prismaTables = [];
   let schema = null;
   let db = null;
+  const kyselyTableContents = {};
   if (config.destinations.length === 0) {
     throw new Error("Empty destinations object.");
   }
@@ -696,7 +686,7 @@ async function generate(config) {
 								AND column_name = $3
 							)
 						ORDER BY
-							e.enumsortorder
+							e.enumlabel
 					`,
             [schema2, table, column.Field]
           );
@@ -769,16 +759,21 @@ async function generate(config) {
     if (!config.destinations || config.destinations.length === 0) {
       throw new Error("No destinations specified");
     }
-    for (const destination of config.destinations) {
+    const kyselyDestinations = config.destinations.filter(
+      (d) => d.type === "kysely"
+    );
+    const nonKyselyDestinations = config.destinations.filter(
+      (d) => d.type !== "kysely"
+    );
+    for (const destination of nonKyselyDestinations) {
       const content = generateContent({
         table,
-        describes,
+        describes: describes.sort((a, b) => a.Field.localeCompare(b.Field)),
         config,
         destination,
         isCamelCase: isCamelCase === true,
         enumDeclarations,
-        defaultZodHeader,
-        defaultKyselyHeader
+        defaultZodHeader
       });
       const suffix = destination.suffix || "";
       const folder = destination.folder || ".";
@@ -792,8 +787,88 @@ async function generate(config) {
         fs.outputFileSync(dest, content);
       }
     }
+    for (const destination of kyselyDestinations) {
+      const content = generateContent({
+        table,
+        describes: describes.sort((a, b) => a.Field.localeCompare(b.Field)),
+        config,
+        destination,
+        isCamelCase: isCamelCase === true,
+        enumDeclarations,
+        defaultZodHeader
+      });
+      const outFile = destination.outFile || "db.ts";
+      if (!kyselyTableContents[outFile]) {
+        kyselyTableContents[outFile] = [];
+      }
+      kyselyTableContents[outFile].push({
+        table,
+        content
+      });
+      if (config.dryRun) {
+        const tempKey = `${table}.kysely.temp`;
+        dryRunOutput[tempKey] = content;
+      }
+    }
   }
   if (db) await db.destroy();
+  for (const [outFile, tableContents] of Object.entries(kyselyTableContents)) {
+    if (tableContents.length === 0) continue;
+    const kyselyDestination = config.destinations.find(
+      (d) => d.type === "kysely"
+    );
+    const header = kyselyDestination?.header || defaultKyselyHeader;
+    const schemaName = kyselyDestination?.schemaName || "DB";
+    let consolidatedContent = `${header}
+
+// JSON type definitions
+export type Json = ColumnType<JsonValue, string, string>;
+
+export type JsonArray = JsonValue[];
+
+export type JsonObject = {
+  [x: string]: JsonValue | undefined;
+};
+
+export type JsonPrimitive = boolean | number | string | null;
+
+export type JsonValue = JsonArray | JsonObject | JsonPrimitive;
+
+`;
+    consolidatedContent += "// Table Interfaces\n";
+    for (const { content } of tableContents) {
+      consolidatedContent += `${content}
+`;
+    }
+    consolidatedContent += `
+// Database Interface
+export interface ${schemaName} {
+`;
+    const sortedTableEntries = tableContents.map(({ table }) => {
+      const pascalTable = camelCase(table, { pascalCase: true });
+      const tableKey = isCamelCase ? camelCase(table) : table;
+      return { tableKey, pascalTable };
+    }).sort((a, b) => a.tableKey.localeCompare(b.tableKey));
+    for (const { tableKey, pascalTable } of sortedTableEntries) {
+      consolidatedContent += `  ${tableKey}: ${pascalTable};
+`;
+    }
+    consolidatedContent += "}\n";
+    if (config.dryRun) {
+      const fileName = path.basename(outFile);
+      dryRunOutput[fileName] = consolidatedContent;
+      for (const key of Object.keys(dryRunOutput)) {
+        if (key.endsWith(".kysely.temp")) {
+          delete dryRunOutput[key];
+        }
+      }
+    } else {
+      const dest = path.resolve(outFile);
+      dests.push(dest);
+      if (!config.silent) console.log("Created:", dest);
+      fs.outputFileSync(dest, consolidatedContent);
+    }
+  }
   return config.dryRun ? dryRunOutput : dests;
 }
 export {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "mutano",
 	"type": "module",
-	"version": "2.1.0",
+	"version": "2.2.0",
 	"description": "Converts Prisma/MySQL/PostgreSQL/SQLite schemas to Zod/TS/Kysely interfaces",
 	"author": "Alisson Cavalcante Agiani <thelinuxlich@gmail.com>",
 	"license": "MIT",
@@ -19,15 +19,15 @@
 		"fs-extra": "^11.3.0",
 		"knex": "^3.1.0",
 		"mysql2": "^3.14.1",
-		"pg": "^8.15.6",
+		"pg": "^8.16.0",
 		"sqlite3": "^5.1.7"
 	},
 	"devDependencies": {
 		"@types/fs-extra": "^11.0.4",
-		"esbuild": "^0.25.3",
+		"esbuild": "^0.25.4",
 		"ts-node": "^10.9.2",
 		"tsx": "^4.19.4",
 		"typescript": "^5.8.3",
-		"vitest": "^3.1.2"
+		"vitest": "^3.1.3"
 	}
 }