mutano 2.0.0 → 2.2.0

package/README.md

@@ -9,6 +9,7 @@ Converts Prisma/MySQL/PostgreSQL/SQLite schemas to Zod schemas, TypeScript inter
 - Handles nullable, default, auto-increment and enum fields
 - Supports custom type overrides via configuration or database comments
 - Intelligently handles field nullability based on operation type (table, insertable, updateable, selectable)
+- All fields in updateable schemas are automatically made optional
 
 ## Installation
 
@@ -57,7 +58,7 @@ await generate({
     type: 'zod',
     useDateType: true,
     useTrim: false,
-    nullish: false,
+    nullish: false, // When true, nullable fields use nullish() instead of nullable()
     folder: './generated',
     suffix: 'schema'
   }]
@@ -303,16 +304,16 @@ export const insertable_user = z.object({
 })
 
 export const updateable_user = z.object({
-  name: z.string().min(10).max(255),
-  username: z.string(),
-  password: z.string(),
-  profile_picture: z.string().nullable(),
-  role: z.enum(['admin', 'user']),
+  name: z.string().min(10).max(255).optional(),
+  username: z.string().optional(),
+  password: z.string().optional(),
+  profile_picture: z.string().nullable().optional(),
+  role: z.enum(['admin', 'user']).optional(),
 })
 
 export const selectable_user = z.object({
   id: z.number().nonnegative(),
-  name: z.string().min(10).max(255),
+  name: z.string(),
   username: z.string(),
   password: z.string(),
   profile_picture: z.string().nullable(),
@@ -372,92 +373,6 @@ export interface SelectableUser {
 }
 ```
 
-### TypeScript Interface Output Example (Enum Type for Enums)
-
-```typescript
-// TypeScript interfaces for user
-
-// Enum declarations
-enum RoleEnum {
-  admin = 'admin',
-  user = 'user'
-}
-
-export interface User {
-  id: number;
-  name: string;
-  username: string;
-  password: string;
-  profile_picture: string | null;
-  role: RoleEnum;
-}
-
-export interface InsertableUser {
-  name: string | null; // Optional because it has a default value
-  username: string;
-  password: string;
-  profile_picture: string | null;
-  role: RoleEnum;
-}
-
-export interface UpdateableUser {
-  name: string | null; // Optional for updates
-  username: string | null; // Optional for updates
-  password: string | null; // Optional for updates
-  profile_picture: string | null;
-  role: RoleEnum | null; // Optional for updates
-}
-
-export interface SelectableUser {
-  id: number;
-  name: string;
-  username: string;
-  password: string;
-  profile_picture: string | null;
-  role: RoleEnum;
-}
-```
-
-### TypeScript Type Alias Output Example
-
-```typescript
-// TypeScript types for user
-
-export type User = {
-  id: number;
-  name: string;
-  username: string;
-  password: string;
-  profile_picture: string | null;
-  role: 'admin' | 'user';
-}
-
-export type InsertableUser = {
-  name: string | null; // Optional because it has a default value
-  username: string;
-  password: string;
-  profile_picture: string | null;
-  role: 'admin' | 'user';
-}
-
-export type UpdateableUser = {
-  name: string | null; // Optional for updates
-  username: string | null; // Optional for updates
-  password: string | null; // Optional for updates
-  profile_picture: string | null;
-  role: 'admin' | 'user' | null; // Optional for updates
-}
-
-export type SelectableUser = {
-  id: number;
-  name: string;
-  username: string;
-  password: string;
-  profile_picture: string | null;
-  role: 'admin' | 'user';
-}
-```
-
 ### Kysely Type Definitions Output Example
 
 ```typescript
@@ -500,49 +415,6 @@ export type NewUser = Insertable<UserTable>;
 export type UserUpdate = Updateable<UserTable>;
 ```
 
-### Kysely Type Definitions Output Example with Custom Schema Name
-
-```typescript
-import { Generated, ColumnType, Selectable, Insertable, Updateable } from 'kysely';
-import { CustomTypes } from './types';
-
-// 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;
-
-// Kysely type definitions for user
-
-// This interface defines the structure of the 'user' table
-export interface UserTable {
-  id: Generated<number>;
-  name: string;
-  username: string;
-  password: string;
-  profile_picture: string | null;
-  metadata: Json;
-  role: 'admin' | 'user';
-}
-
-// Define the database interface
-export interface Database {
-  user: UserTable;
-}
-
-// Use these types for inserting, selecting and updating the table
-export type User = Selectable<UserTable>;
-export type NewUser = Insertable<UserTable>;
-export type UserUpdate = Updateable<UserTable>;
-```
-
 ## Config
 
 ```json
@@ -596,8 +468,8 @@ export type UserUpdate = Updateable<UserTable>;
       "type": "zod",
       "useDateType": true,
       "useTrim": false,
-      "nullish": false,
-      "requiredString": false,
+      "nullish": false, // When true, nullable fields use nullish() instead of nullable()
+      "requiredString": false, // When true, adds min(1) validation to non-nullable string fields
       "header": "import { z } from 'zod';\nimport { CustomValidator } from './validators';",
       "folder": "@zod",
       "suffix": "table"
@@ -633,8 +505,8 @@ export type UserUpdate = Updateable<UserTable>;
 | destinations[].type | The type of output to generate: "zod", "ts", or "kysely" |
 | destinations[].useDateType | (Zod only) Use a specialized Zod type for date-like fields instead of string |
 | destinations[].useTrim | (Zod only) Use `z.string().trim()` instead of `z.string()` |
-| destinations[].nullish | (Zod only) Set schema as `nullish` instead of `nullable` |
-| destinations[].requiredString | (Zod only) Add `min(1)` for string schema |
+| destinations[].nullish | (Zod only) Use `nullish()` instead of `nullable()` for nullable fields. In updateable schemas, fields that were already nullable will become nullish |
+| destinations[].requiredString | (Zod only) Add `min(1)` for non-nullable string fields |
 | destinations[].enumType | (TypeScript only) How to represent enum types: "union" (default) or "enum" |
 | destinations[].modelType | (TypeScript only) How to represent models: "interface" (default) or "type" |
 | destinations[].schemaName | (Kysely only) Name of the database interface (default: "DB") |

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

@@ -164,6 +164,7 @@ function getType(op, desc, config, destination, tableName) {
   const { Default, Extra, Null, Type, Comment, EnumOptions } = desc;
   const isZodDestination = destination.type === "zod";
   const isTsDestination = destination.type === "ts";
+  const isKyselyDestination = destination.type === "kysely";
   const isNullish = isZodDestination && destination.type === "zod" && destination.nullish === true;
   const isTrim = isZodDestination && destination.type === "zod" && destination.useTrim === true && op !== "selectable";
   const isUseDateType = isZodDestination && destination.type === "zod" && destination.useDateType === true;
@@ -174,11 +175,11 @@ function getType(op, desc, config, destination, tableName) {
     return;
   const isRequiredString = destination.type === "zod" && destination.requiredString === true && op !== "selectable";
   const type = schemaType === "mysql" ? Type.split("(")[0].split(" ")[0] : Type;
-  if (isTsDestination) {
+  if (isTsDestination || isKyselyDestination) {
     const tsOverrideType = config.magicComments ? extractTSExpression(Comment) : null;
     const shouldBeNullable = isNull || ["insertable", "updateable"].includes(op) && (hasDefaultValue || isGenerated) || op === "updateable" && !isNull && !hasDefaultValue;
     if (tsOverrideType) {
-      return shouldBeNullable ? `${tsOverrideType} | null` : tsOverrideType;
+      return shouldBeNullable ? tsOverrideType.includes("| null") ? tsOverrideType : `${tsOverrideType} | null` : tsOverrideType;
     }
     if (dateTypes[schemaType].includes(type)) {
       return shouldBeNullable ? "Date | null" : "Date";
@@ -198,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";
@@ -302,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)
@@ -326,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);
@@ -364,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) {
@@ -381,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";
@@ -552,6 +542,10 @@ 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.");
+  }
   const dryRunOutput = {};
   if (config.origin.type === "mysql") {
     db = knex({
@@ -692,7 +686,7 @@ async function generate(config) {
 								AND column_name = $3
 							)
 						ORDER BY
-							e.enumsortorder
+							e.enumlabel
 					`,
             [schema2, table, column.Field]
           );
@@ -765,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 || ".";
@@ -788,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.0.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,13 +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"
 	}
 }