mutano 3.0.2 → 3.0.4

package/package.json

@@ -1,20 +1,24 @@
 {
   "name": "mutano",
   "type": "module",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "description": "Converts Prisma/MySQL/PostgreSQL/SQLite schemas to Zod/TS/Kysely interfaces",
   "author": "Alisson Cavalcante Agiani <thelinuxlich@gmail.com>",
   "license": "MIT",
   "repository": "git@github.com:thelinuxlich/mutano.git",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "esbuild src/main.ts --format=esm --platform=node --outfile=dist/main.js && tsc src/main.ts -d --emitDeclarationOnly --esModuleInterop --outDir dist",
+    "build": "pkgroll",
     "test": "vitest run"
   },
   "dependencies": {
     "@mrleebo/prisma-ast": "^0.13.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/pg": "^8.15.5",
     "camelcase": "^8.0.0",
     "fs-extra": "^11.3.2",
     "knex": "^3.1.0",
@@ -24,11 +28,7 @@
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.3.8",
-    "@types/fs-extra": "^11.0.4",
-    "@types/pg": "^8.15.5",
-    "esbuild": "^0.25.9",
-    "ts-node": "^10.9.2",
-    "tsx": "4.19.4",
+    "pkgroll": "^2.15.4",
     "typescript": "^5.9.2",
     "vitest": "^3.2.4"
   }

package/dist/constants.d.ts

@@ -1,6 +0,0 @@
-/**
- * Constants and default headers for code generation
- */
-export declare const defaultKyselyHeader = "import { Generated, Insertable, Selectable, Updateable, ColumnType } from 'kysely';\n\n";
-export declare const defaultZodHeader: (version: 3 | 4) => string;
-export declare const kyselyJsonTypes = "// JSON type definitions\nexport type Json = ColumnType<JsonValue, string, string>;\n\nexport type JsonArray = JsonValue[];\n\nexport type JsonObject = {\n  [x: string]: JsonValue | undefined;\n};\n\nexport type JsonPrimitive = boolean | number | string | null;\n\nexport type JsonValue = JsonArray | JsonObject | JsonPrimitive;\n\nexport type Generated<T> = T extends ColumnType<infer S, infer I, infer U>\n  ? ColumnType<S, I | undefined, U>\n  : ColumnType<T, T | undefined, T>\n\nexport type Decimal = ColumnType<string, number | string, number | string>\n\nexport type BigInt = ColumnType<string, number | string, number | string>\n\n";

package/dist/database/connection.d.ts

@@ -1,25 +0,0 @@
-/**
- * Database connection and schema extraction utilities
- */
-import knex from 'knex';
-import type { Config, Desc } from '../types/index.js';
-/**
- * Create a database connection based on config
- */
-export declare function createDatabaseConnection(config: Config): knex.Knex<any, unknown[]>;
-/**
- * Extract table names from database
- */
-export declare function extractTables(db: ReturnType<typeof knex>, config: Config): Promise<string[]>;
-/**
- * Extract view names from database
- */
-export declare function extractViews(db: ReturnType<typeof knex>, config: Config): Promise<string[]>;
-/**
- * Extract column descriptions for a table or view
- */
-export declare function extractColumnDescriptions(db: ReturnType<typeof knex>, config: Config, tableName: string): Promise<Desc[]>;
-/**
- * Extract enum values for PostgreSQL user-defined types
- */
-export declare function extractEnumValues(db: ReturnType<typeof knex>, config: Config, typeName: string): Promise<string[]>;

package/dist/database/prisma.d.ts

@@ -1,20 +0,0 @@
-/**
- * Prisma schema extraction utilities
- */
-import type { Config, Desc } from '../types/index.js';
-/**
- * Extract tables and views from Prisma schema
- */
-export declare function extractPrismaEntities(config: Config): {
-    tables: string[];
-    views: string[];
-    enumDeclarations: Record<string, string[]>;
-};
-/**
- * Extract column descriptions from Prisma model or view
- */
-export declare function extractPrismaColumnDescriptions(config: Config, entityName: string, enumDeclarations: Record<string, string[]>): Desc[];
-/**
- * Check if Prisma schema has views enabled
- */
-export declare function hasViewsEnabled(config: Config): boolean;

package/dist/generators/content-generator.d.ts

@@ -1,12 +0,0 @@
-/**
- * Content generation for tables and views
- */
-import type { GenerateContentParams, GenerateViewContentParams } from '../types/index.js';
-/**
- * Generate content for database views (read-only)
- */
-export declare function generateViewContent({ view, describes, config, destination, isCamelCase, enumDeclarations: _enumDeclarations, defaultZodHeader, }: GenerateViewContentParams): string;
-/**
- * Generate content for database tables
- */
-export declare function generateContent({ table, describes, config, destination, isCamelCase, enumDeclarations: _enumDeclarations, defaultZodHeader, }: GenerateContentParams): string;

package/dist/generators/type-generator.d.ts

@@ -1,9 +0,0 @@
-/**
- * Core type generation logic
- */
-import type { Config, Desc, Destination } from '../types/index.js';
-export type OperationType = 'table' | 'insertable' | 'updateable' | 'selectable';
-/**
- * Generate the appropriate type for a database field
- */
-export declare function getType(op: OperationType, desc: Desc, config: Config, destination: Destination): string;

package/dist/types/index.d.ts

@@ -1,107 +0,0 @@
-/**
- * Core types and interfaces for Mutano
- */
-export interface Desc {
-    Field: string;
-    Default: string | null;
-    Extra: string;
-    Null: string;
-    Type: string;
-    Comment: string;
-    EnumOptions?: string[];
-}
-export type Destination = {
-    type: 'zod';
-    useDateType?: boolean;
-    useTrim?: boolean;
-    nullish?: boolean;
-    requiredString?: boolean;
-    version?: 3 | 4;
-    header?: string;
-    folder?: string;
-    suffix?: string;
-} | {
-    type: 'ts';
-    enumType?: 'union' | 'enum';
-    modelType?: 'interface' | 'type';
-    header?: string;
-    folder?: string;
-    suffix?: string;
-} | {
-    type: 'kysely';
-    schemaName?: string;
-    header?: string;
-    folder?: string;
-    suffix?: string;
-    outFile?: string;
-};
-export interface Config {
-    origin: {
-        type: 'prisma';
-        path: string;
-        overrideTypes?: {
-            [k in PrismaValidTypes]?: string;
-        };
-    } | {
-        type: 'mysql';
-        host: string;
-        port: number;
-        user: string;
-        password: string;
-        database: string;
-        overrideTypes?: {
-            [k in MySQLValidTypes]?: string;
-        };
-        ssl?: Record<string, any>;
-    } | {
-        type: 'postgres';
-        host: string;
-        port: number;
-        user: string;
-        password: string;
-        database: string;
-        schema?: string;
-        overrideTypes?: {
-            [k in PostgresValidTypes]?: string;
-        };
-        ssl?: Record<string, any>;
-    } | {
-        type: 'sqlite';
-        path: string;
-        overrideTypes?: {
-            [k in SQLiteValidTypes]?: string;
-        };
-    };
-    destinations: Destination[];
-    tables?: string[];
-    views?: string[];
-    ignore?: string[];
-    ignoreViews?: string[];
-    camelCase?: boolean;
-    silent?: boolean;
-    dryRun?: boolean;
-    magicComments?: boolean;
-    includeViews?: boolean;
-}
-export interface GenerateContentParams {
-    table: string;
-    describes: Desc[];
-    config: Config;
-    destination: Destination;
-    isCamelCase: boolean;
-    enumDeclarations: Record<string, string[]>;
-    defaultZodHeader: (version: 3 | 4) => string;
-}
-export interface GenerateViewContentParams {
-    view: string;
-    describes: Desc[];
-    config: Config;
-    destination: Destination;
-    isCamelCase: boolean;
-    enumDeclarations: Record<string, string[]>;
-    defaultZodHeader: (version: 3 | 4) => string;
-}
-export type MySQLValidTypes = 'tinyint' | 'smallint' | 'mediumint' | 'int' | 'bigint' | 'decimal' | 'float' | 'double' | 'bit' | 'char' | 'varchar' | 'binary' | 'varbinary' | 'tinyblob' | 'blob' | 'mediumblob' | 'longblob' | 'tinytext' | 'text' | 'mediumtext' | 'longtext' | 'enum' | 'set' | 'date' | 'time' | 'datetime' | 'timestamp' | 'year' | 'json';
-export type PostgresValidTypes = 'smallint' | 'integer' | 'bigint' | 'decimal' | 'numeric' | 'real' | 'double precision' | 'smallserial' | 'serial' | 'bigserial' | 'money' | 'character varying' | 'varchar' | 'character' | 'char' | 'text' | 'bytea' | 'timestamp' | 'timestamp with time zone' | 'timestamp without time zone' | 'date' | 'time' | 'time with time zone' | 'time without time zone' | 'interval' | 'boolean' | 'enum' | 'point' | 'line' | 'lseg' | 'box' | 'path' | 'polygon' | 'circle' | 'cidr' | 'inet' | 'macaddr' | 'bit' | 'bit varying' | 'uuid' | 'xml' | 'json' | 'jsonb' | 'int4range' | 'int8range' | 'numrange' | 'tsrange' | 'tstzrange' | 'daterange' | 'name' | 'citext';
-export type SQLiteValidTypes = 'integer' | 'real' | 'text' | 'blob' | 'numeric' | 'boolean' | 'date' | 'datetime' | 'character' | 'varchar' | 'varying character' | 'nchar' | 'native character' | 'nvarchar' | 'clob' | 'double' | 'double precision' | 'float' | 'int' | 'int2' | 'int8' | 'bigint' | 'unsigned big int' | 'mediumint' | 'tinyint' | 'smallint' | 'decimal' | 'json';
-export type PrismaValidTypes = 'String' | 'Boolean' | 'Int' | 'BigInt' | 'Float' | 'Decimal' | 'DateTime' | 'Json' | 'Bytes' | 'Unsupported';

package/dist/types/mappings.d.ts

@@ -1,91 +0,0 @@
-/**
- * Database type mappings for different database systems
- */
-export declare const prismaValidTypes: readonly ["String", "Boolean", "Int", "BigInt", "Float", "Decimal", "DateTime", "Json", "Bytes", "Unsupported"];
-export declare const dateTypes: {
-    mysql: string[];
-    postgres: string[];
-    sqlite: string[];
-    prisma: string[];
-};
-export declare const stringTypes: {
-    mysql: string[];
-    postgres: string[];
-    sqlite: string[];
-    prisma: string[];
-};
-export declare const bigIntTypes: {
-    mysql: string[];
-    postgres: string[];
-    sqlite: string[];
-    prisma: string[];
-};
-export declare const numberTypes: {
-    mysql: string[];
-    postgres: string[];
-    sqlite: string[];
-    prisma: string[];
-};
-export declare const decimalTypes: {
-    mysql: string[];
-    postgres: string[];
-    sqlite: string[];
-    prisma: string[];
-};
-export declare const booleanTypes: {
-    mysql: string[];
-    postgres: string[];
-    sqlite: string[];
-    prisma: string[];
-};
-export declare const enumTypes: {
-    mysql: string[];
-    postgres: string[];
-    sqlite: string[];
-    prisma: string[];
-};
-export declare const enumRegex: RegExp;
-/**
- * Get the appropriate type mappings for a database type
- */
-export declare function getTypeMappings(dbType: 'mysql' | 'postgres' | 'sqlite' | 'prisma'): {
-    dateTypes: string[];
-    stringTypes: string[];
-    bigIntTypes: string[];
-    numberTypes: string[];
-    decimalTypes: string[];
-    booleanTypes: string[];
-    enumTypes: string[];
-};
-/**
- * Check if a type is a JSON type
- */
-export declare function isJsonType(type: string): boolean;
-/**
- * Check if a type is a date type for a specific database
- */
-export declare function isDateType(type: string, dbType: 'mysql' | 'postgres' | 'sqlite' | 'prisma'): boolean;
-/**
- * Check if a type is a string type for a specific database
- */
-export declare function isStringType(type: string, dbType: 'mysql' | 'postgres' | 'sqlite' | 'prisma'): boolean;
-/**
- * Check if a type is a number type for a specific database
- */
-export declare function isNumberType(type: string, dbType: 'mysql' | 'postgres' | 'sqlite' | 'prisma'): boolean;
-/**
- * Check if a type is a bigint type for a specific database
- */
-export declare function isBigIntType(type: string, dbType: 'mysql' | 'postgres' | 'sqlite' | 'prisma'): boolean;
-/**
- * Check if a type is a decimal type for a specific database
- */
-export declare function isDecimalType(type: string, dbType: 'mysql' | 'postgres' | 'sqlite' | 'prisma'): boolean;
-/**
- * Check if a type is a boolean type for a specific database
- */
-export declare function isBooleanType(type: string, dbType: 'mysql' | 'postgres' | 'sqlite' | 'prisma'): boolean;
-/**
- * Check if a type is an enum type for a specific database
- */
-export declare function isEnumType(type: string, dbType: 'mysql' | 'postgres' | 'sqlite' | 'prisma'): boolean;

package/dist/utils/filters.d.ts

@@ -1,23 +0,0 @@
-/**
- * Utilities for filtering tables and views
- */
-/**
- * Filter entities (tables or views) based on include/exclude patterns
- */
-export declare function filterEntities(entities: string[], included?: string[], ignored?: string[]): string[];
-/**
- * Filter tables based on configuration
- */
-export declare function filterTables(tables: string[], includedTables?: string[], ignoredTables?: string[]): string[];
-/**
- * Filter views based on configuration
- */
-export declare function filterViews(views: string[], includedViews?: string[], ignoredViews?: string[]): string[];
-/**
- * Create entity objects with type information
- */
-export interface EntityInfo {
-    name: string;
-    type: 'table' | 'view';
-}
-export declare function createEntityList(tables: string[], views: string[]): EntityInfo[];

package/dist/utils/magic-comments.d.ts

@@ -1,33 +0,0 @@
-/**
- * Utilities for parsing magic comments (@zod, @ts, @kysely)
- */
-/**
- * Extract type expression from a comment with a given prefix
- * Handles nested parentheses, brackets, and braces
- */
-export declare const extractTypeExpression: (comment: string, prefix: string) => string | null;
-/**
- * Extract TypeScript type expression from @ts() comment
- */
-export declare const extractTSExpression: (comment: string) => string | null;
-/**
- * Extract Kysely type expression from @kysely() comment
- */
-export declare const extractKyselyExpression: (comment: string) => string | null;
-/**
- * Extract Zod type expression from @zod() comment
- */
-export declare const extractZodExpression: (comment: string) => string | null;
-/**
- * Check if a comment contains any magic comment
- */
-export declare const hasMagicComment: (comment: string) => boolean;
-/**
- * Parse all magic comments from a comment string
- */
-export interface MagicComments {
-    zod?: string;
-    ts?: string;
-    kysely?: string;
-}
-export declare const parseMagicComments: (comment: string) => MagicComments;