mutano 2.3.0 → 2.5.0

package/README.md

@@ -30,7 +30,7 @@ CREATE TABLE `user` (
   `username` varchar(255) NOT NULL,
   `password` varchar(255) NOT NULL,
   `profile_picture` varchar(255) DEFAULT NULL,
-  `metadata` json NOT NULL COMMENT '@ts(Record<string, unknown>)', -- this will override the TypeScript type
+  `metadata` json NOT NULL COMMENT '@ts(Record<string, unknown>) @kysely(Record<string, string>)', -- this will override the TypeScript and Kysely type
   `role` enum('admin','user') NOT NULL,
   PRIMARY KEY (`id`)
 );
@@ -184,7 +184,7 @@ const output = await generate({
   destinations: [{
     type: 'zod'
   }],
-  dryRun: true // Return content instead of writing to files
+  dryRun: true // Return content and don't write to files
 })
 
 // Output is an object where keys are filenames and values are file content
@@ -400,7 +400,7 @@ export interface UserTable {
   username: string;
   password: string;
   profile_picture: string | null;
-  metadata: Json;
+  metadata: Record<string, unknown>; // Custom type from @kysely comment
   role: 'admin' | 'user';
 }
 
@@ -486,8 +486,7 @@ export type UserUpdate = Updateable<UserTable>;
       "type": "kysely",
       "schemaName": "Database",
       "header": "import { Generated, ColumnType } from 'kysely';\nimport { CustomTypes } from './types';",
-      "folder": "kysely",
-      "suffix": "db"
+      "outFile": "db.ts"
     }
   ],
   "tables": ["user", "log"],
@@ -513,6 +512,7 @@ export type UserUpdate = Updateable<UserTable>;
 | destinations[].header | Custom header to include at the beginning of generated files (e.g., custom imports) |
 | destinations[].folder | Specify the output directory for the generated files |
 | destinations[].suffix | Suffix to the name of a generated file (eg: `user.table.ts`) |
+| destinations[].outFile | (Kysely only) Specify the output file for the generated content. All tables will be written to this file |
 | tables | Filter the tables to include only those specified |
 | ignore | Filter the tables to exclude those specified. If a table name begins and ends with "/", it will be processed as a regular expression |
 | camelCase | Convert all table names and their properties to camelcase. (eg: `profile_picture` becomes `profilePicture`) |
@@ -641,7 +641,30 @@ export interface User {
 }
 ```
 
-You can use complex TypeScript types in the `@ts` comment:
+### @kysely Comments
+
+You can use the `@kysely` comment to override the Kysely type for a specific column. This is useful when you want to specify a more precise type for a field.
+
+```sql
+CREATE TABLE `user` (
+  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+  `metadata` json NOT NULL COMMENT '@kysely(Record<string, string>)',
+  PRIMARY KEY (`id`)
+);
+```
+
+This will generate:
+
+```typescript
+export interface UserTable {
+  id: Generated<number>;
+  metadata: Record<string, string>;
+}
+```
+
+## Complex TypeScript Types
+
+You can use complex TypeScript types in the `@ts`(or `@kysely`) comment:
 
 ```sql
 CREATE TABLE `product` (

package/dist/main.d.ts

@@ -1,3 +1,7 @@
+export declare const extractTypeExpression: (comment: string, prefix: string) => string;
+export declare const extractTSExpression: (comment: string) => string;
+export declare const extractKyselyExpression: (comment: string) => string;
+export declare const extractZodExpression: (comment: string) => string;
 export declare function getType(op: 'table' | 'insertable' | 'updateable' | 'selectable', desc: Desc, config: Config, destination: Destination, tableName?: string): string;
 export interface GenerateContentParams {
     table: string;

package/dist/main.js

@@ -7,10 +7,10 @@ import {
 import camelCase from "camelcase";
 import fs from "fs-extra";
 import knex from "knex";
-const extractTSExpression = (comment) => {
-  const start = comment.indexOf("@ts(");
+const extractTypeExpression = (comment, prefix) => {
+  const start = comment.indexOf(prefix);
   if (start === -1) return null;
-  const typeLen = 4;
+  const typeLen = prefix.length;
   let position = start + typeLen;
   let depth = 1;
   while (position < comment.length && depth > 0) {
@@ -28,24 +28,9 @@ const extractTSExpression = (comment) => {
   }
   return null;
 };
-function extractZodExpression(comment) {
-  const zodStart = comment.indexOf("@zod(");
-  if (zodStart === -1) return null;
-  let openParens = 0;
-  let position = zodStart + 5;
-  while (position < comment.length) {
-    if (comment[position] === "(") {
-      openParens++;
-    } else if (comment[position] === ")") {
-      if (openParens === 0) {
-        return comment.substring(zodStart + 5, position);
-      }
-      openParens--;
-    }
-    position++;
-  }
-  return null;
-}
+const extractTSExpression = (comment) => extractTypeExpression(comment, "@ts(");
+const extractKyselyExpression = (comment) => extractTypeExpression(comment, "@kysely(");
+const extractZodExpression = (comment) => extractTypeExpression(comment, "@zod(");
 const prismaValidTypes = [
   "BigInt",
   "Boolean",
@@ -77,7 +62,6 @@ const stringTypes = {
     "mediumtext",
     "longtext",
     "json",
-    "decimal",
     "time",
     "year",
     "char",
@@ -96,9 +80,7 @@ const stringTypes = {
     "timetz",
     "interval",
     "name",
-    "citext",
-    "numeric",
-    "decimal"
+    "citext"
   ],
   sqlite: [
     "text",
@@ -111,7 +93,7 @@ const stringTypes = {
     "clob",
     "json"
   ],
-  prisma: ["String", "Decimal", "BigInt", "Bytes", "Json"]
+  prisma: ["String", "BigInt", "Bytes", "Json"]
 };
 const numberTypes = {
   mysql: ["smallint", "mediumint", "int", "bigint", "float", "double"],
@@ -119,8 +101,6 @@ const numberTypes = {
     "smallint",
     "integer",
     "bigint",
-    "decimal",
-    "numeric",
     "real",
     "double precision",
     "serial",
@@ -139,12 +119,16 @@ const numberTypes = {
     "real",
     "double",
     "double precision",
-    "float",
-    "numeric",
-    "decimal"
+    "float"
   ],
   prisma: ["Int", "Float"]
 };
+const decimalTypes = {
+  mysql: ["decimal"],
+  postgres: ["decimal", "numeric"],
+  sqlite: ["numeric", "decimal"],
+  prisma: ["Decimal"]
+};
 const booleanTypes = {
   mysql: ["tinyint"],
   postgres: ["boolean", "bool"],
@@ -176,6 +160,13 @@ function getType(op, desc, config, destination, tableName) {
   const isRequiredString = destination.type === "zod" && destination.requiredString === true && op !== "selectable";
   const type = schemaType === "mysql" ? Type.split("(")[0].split(" ")[0] : Type;
   if (isTsDestination || isKyselyDestination) {
+    if (isKyselyDestination && config.magicComments) {
+      const kyselyOverrideType = extractKyselyExpression(Comment);
+      if (kyselyOverrideType) {
+        const shouldBeNullable2 = isNull || ["insertable", "updateable"].includes(op) && (hasDefaultValue || isGenerated) || op === "updateable" && !isNull && !hasDefaultValue;
+        return shouldBeNullable2 ? kyselyOverrideType.includes("| null") ? kyselyOverrideType : `${kyselyOverrideType} | null` : kyselyOverrideType;
+      }
+    }
     const tsOverrideType = config.magicComments ? extractTSExpression(Comment) : null;
     const shouldBeNullable = isNull || ["insertable", "updateable"].includes(op) && (hasDefaultValue || isGenerated) || op === "updateable" && !isNull && !hasDefaultValue;
     if (tsOverrideType) {
@@ -193,6 +184,12 @@ function getType(op, desc, config, destination, tableName) {
     if (booleanTypes[schemaType].includes(type)) {
       return shouldBeNullable ? "boolean | null" : "boolean";
     }
+    if (decimalTypes[schemaType].includes(type) || type === "Decimal") {
+      if (isKyselyDestination) {
+        return shouldBeNullable ? "Decimal | null" : "Decimal";
+      }
+      return shouldBeNullable ? "string | null" : "string";
+    }
     if (schemaType !== "sqlite" && enumTypes[schemaType].includes(type)) {
       const enumType = destination.type === "ts" ? destination.enumType || "union" : "union";
       let enumValues = [];
@@ -324,6 +321,16 @@ function getType(op, desc, config, destination, tableName) {
   if (dateTypes[schemaType].includes(type)) return generateDateLikeField();
   if (stringTypes[schemaType].includes(type)) return generateStringLikeField();
   if (numberTypes[schemaType].includes(type)) return generateNumberLikeField();
+  if (decimalTypes[schemaType].includes(type) || type === "Decimal") {
+    if (isKyselyDestination) {
+      const isNull2 = Null === "YES";
+      const hasDefaultValue2 = Default !== null;
+      const isGenerated2 = Extra.toLowerCase().includes("auto_increment") || Extra.toLowerCase().includes("default_generated");
+      const shouldBeNullable = isNull2 || ["insertable", "updateable"].includes(op) && (hasDefaultValue2 || isGenerated2) || op === "updateable" && !isNull2 && !hasDefaultValue2;
+      return shouldBeNullable ? "Decimal | null" : "Decimal";
+    }
+    return generateStringLikeField();
+  }
   if (booleanTypes[schemaType].includes(type)) return generateBooleanLikeField();
   if (schemaType !== "sqlite" && enumTypes[schemaType].includes(type))
     return generateEnumLikeField();
@@ -359,15 +366,26 @@ export interface ${camelCase(table, { pascalCase: true })} {`;
         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 || isEnum && hasDefaultValue) {
-          kyselyType = `Generated<${kyselyType}>`;
-        }
-        if (isNullable && !isJsonField) {
-          if (!kyselyType.includes("| null")) {
+        const kyselyOverrideType = config.magicComments ? extractKyselyExpression(desc.Comment) : null;
+        if (kyselyOverrideType) {
+          kyselyType = kyselyOverrideType;
+          if (isNullable && !kyselyType.includes("| null")) {
             kyselyType = `${kyselyType} | null`;
           }
+          if (isAutoIncrement || isDefaultGenerated || hasDefaultValue && (isEnum || kyselyType === "string" || kyselyType === "boolean" || kyselyType === "number" || kyselyType === "Decimal" || kyselyType.includes("boolean | null") || kyselyType.includes("string | null") || kyselyType.includes("number | null") || kyselyType.includes("Decimal | null"))) {
+            kyselyType = `Generated<${kyselyType}>`;
+          }
+        } else if (isJsonField) {
+          kyselyType = "Json";
+        } else {
+          if (isNullable && !isJsonField) {
+            if (!kyselyType.includes("| null")) {
+              kyselyType = `${kyselyType} | null`;
+            }
+          }
+          if (isAutoIncrement || isDefaultGenerated || hasDefaultValue && (isEnum || kyselyType === "string" || kyselyType === "boolean" || kyselyType === "number" || kyselyType === "Decimal" || kyselyType.includes("boolean | null") || kyselyType.includes("string | null") || kyselyType.includes("number | null") || kyselyType.includes("Decimal | null"))) {
+            kyselyType = `Generated<${kyselyType}>`;
+          }
         }
         content = `${content}
   ${field}: ${kyselyType};`;
@@ -835,6 +853,8 @@ export type JsonPrimitive = boolean | number | string | null;
 
 export type JsonValue = JsonArray | JsonObject | JsonPrimitive;
 
+export type Decimal = ColumnType<string, number | string>
+
 `;
     consolidatedContent += "// Table Interfaces\n";
     for (const { content } of tableContents) {
@@ -889,6 +909,10 @@ export interface ${schemaName} {
 export {
   defaultKyselyHeader,
   defaultZodHeader,
+  extractKyselyExpression,
+  extractTSExpression,
+  extractTypeExpression,
+  extractZodExpression,
   generate,
   generateContent,
   getType

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "mutano",
 	"type": "module",
-	"version": "2.3.0",
+	"version": "2.5.0",
 	"description": "Converts Prisma/MySQL/PostgreSQL/SQLite schemas to Zod/TS/Kysely interfaces",
 	"author": "Alisson Cavalcante Agiani <thelinuxlich@gmail.com>",
 	"license": "MIT",