mutano 3.0.0 → 3.0.2

package/dist/types/index.d.ts

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

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

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

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

package/package.json

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