mutano 3.0.1 → 3.0.2

package/README.md

@@ -2,7 +2,8 @@
 
 Convert database schemas to TypeScript types, Zod schemas, or Kysely definitions.
 
-**Supports:** MySQL, PostgreSQL, SQLite, Prisma • **Features:** Views, Magic Comments, Type Overrides, Multiple Outputs
+- **Supports:** MySQL, PostgreSQL, SQLite, Prisma 
+- **Features:** Views, Magic Comments, Type Overrides, Multiple Outputs
 
 ## Installation
 
@@ -51,15 +52,6 @@ await generate({
 })
 ```
 
-## Database Support
-
-| Database | Connection | Views | Magic Comments |
-|----------|------------|-------|----------------|
-| **MySQL** | Host/Port | ✅ | ✅ |
-| **PostgreSQL** | Host/Port | ✅ | ✅ |
-| **SQLite** | File Path | ✅ | ❌ |
-| **Prisma** | Schema File | ✅ | ❌ |
-
 ## Output Examples
 
 **Zod Schema:**
@@ -177,7 +169,7 @@ export type UserUpdate = Updateable<UserTable>;
 | `includeViews` | Process database views |
 | `camelCase` | Convert to camelCase |
 | `dryRun` | Return content without writing files |
-| `magicComments` | Enable @zod/@ts/@kysely comments |
+| `magicComments` | Enable @zod/@ts/@kysely comments (Obs.: no SQLite support) |
 
 ## Magic Comments
 

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,25 @@
+/**
+ * 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

@@ -0,0 +1,20 @@
+/**
+ * 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

@@ -0,0 +1,12 @@
+/**
+ * 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

@@ -0,0 +1,9 @@
+/**
+ * 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/main.d.ts

@@ -1,100 +1,15 @@
-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;
-    describes: Desc[];
-    config: Config;
-    destination: Destination;
-    isCamelCase: boolean;
-    enumDeclarations: Record<string, string[]>;
-    defaultZodHeader: (version: 3 | 4) => string;
-}
-export declare function generateContent({ table, describes, config, destination, isCamelCase, enumDeclarations, defaultZodHeader, }: GenerateContentParams): string;
-export declare const defaultKyselyHeader = "import { ColumnType, Selectable, Insertable, Updateable } from 'kysely';\n\n";
-export declare const defaultZodHeader: (version: 3 | 4) => string;
+/**
+ * Mutano - Database schema to TypeScript/Zod/Kysely converter
+ * Refactored for better maintainability and modularity
+ */
+import type { Config } from './types/index.js';
+import { defaultKyselyHeader, defaultZodHeader } from './constants.js';
+export { extractTypeExpression, extractTSExpression, extractKyselyExpression, extractZodExpression } from './utils/magic-comments.js';
+export type { Config, Desc, Destination } from './types/index.js';
+export { generateContent, generateViewContent } from './generators/content-generator.js';
+export { getType } from './generators/type-generator.js';
+export { defaultKyselyHeader, defaultZodHeader };
+/**
+ * Main generate function - orchestrates the entire schema generation process
+ */
 export declare function generate(config: Config): Promise<Record<string, string>>;
-type MySQLValidTypes = 'date' | 'datetime' | 'timestamp' | 'time' | 'year' | 'char' | 'varchar' | 'tinytext' | 'text' | 'mediumtext' | 'longtext' | 'json' | 'decimal' | 'tinyint' | 'smallint' | 'mediumint' | 'int' | 'bigint' | 'float' | 'double' | 'enum';
-type PostgresValidTypes = 'date' | 'timestamp' | 'timestamptz' | 'timestamp without time zone' | 'timestamp with time zone' | 'time' | 'timetz' | 'interval' | 'character' | 'varchar' | 'character varying' | 'text' | 'json' | 'jsonb' | 'uuid' | 'name' | 'citext' | 'numeric' | 'decimal' | 'smallint' | 'integer' | 'bigint' | 'real' | 'double precision' | 'serial' | 'bigserial' | 'boolean' | 'bool' | 'USER-DEFINED';
-type SQLiteValidTypes = 'datetime' | 'text' | 'character' | 'varchar' | 'varying character' | 'nchar' | 'native character' | 'nvarchar' | 'clob' | 'json' | 'int' | 'integer' | 'tinyint' | 'smallint' | 'mediumint' | 'bigint' | 'unsigned big int' | 'int2' | 'int8' | 'real' | 'double' | 'double precision' | 'float' | 'numeric' | 'decimal' | 'boolean';
-type PrismaValidTypes = 'DateTime' | 'String' | 'Decimal' | 'BigInt' | 'Bytes' | 'Json' | 'Int' | 'Float' | 'Boolean' | 'Enum';
-export interface Desc {
-    Field: string;
-    Default: string | null;
-    EnumOptions?: string[];
-    Extra: string;
-    Type: string;
-    Null: 'YES' | 'NO';
-    Comment: string;
-}
-export type Destination = {
-    type: 'zod';
-    version?: 3 | 4;
-    header?: string;
-    useDateType?: boolean;
-    useTrim?: boolean;
-    nullish?: boolean;
-    requiredString?: boolean;
-    folder?: string;
-    suffix?: string;
-} | {
-    type: 'ts';
-    header?: string;
-    enumType?: 'enum' | 'union';
-    modelType?: 'interface' | 'type';
-    folder?: string;
-    suffix?: string;
-} | {
-    type: 'kysely';
-    header?: string;
-    schemaName?: 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[];
-    ignore?: string[];
-    camelCase?: boolean;
-    silent?: boolean;
-    dryRun?: boolean;
-    magicComments?: boolean;
-}
-export {};