noormme 1.0.6 → 1.2.0

package/dist/cjs/migration/data_migrator.js

@@ -27,7 +27,9 @@ async function migrateTableData(sourceDb, targetDb, sourceTable, targetTable, so
             };
         }
         // Keyset pagination optimization: find a numeric primary key
-        const pkColumn = sourceTable.columns.find(c => c.primaryKey && (c.type.toLowerCase().includes('int') || c.type.toLowerCase().includes('serial')))?.name;
+        const pkColumn = sourceTable.columns.find((c) => c.primaryKey &&
+            (c.type.toLowerCase().includes('int') ||
+                c.type.toLowerCase().includes('serial')))?.name;
         let lastId = null;
         // Calculate number of batches (approximate)
         const batchCount = Math.ceil(totalRows / options.batchSize);
@@ -108,7 +110,7 @@ function transformRows(rows, sourceTable, targetTable, sourceDialect, targetDial
     // Build transformation map
     const transformations = new Map();
     for (const sourceColumn of sourceTable.columns) {
-        const targetColumn = targetTable.columns.find(c => c.name === sourceColumn.name);
+        const targetColumn = targetTable.columns.find((c) => c.name === sourceColumn.name);
         if (targetColumn) {
             const transform = (0, type_mapper_js_1.getValueTransformation)(sourceColumn.type, targetColumn.type, sourceDialect, targetDialect);
             if (transform) {
@@ -117,7 +119,7 @@ function transformRows(rows, sourceTable, targetTable, sourceDialect, targetDial
         }
     }
     // Transform rows
-    return rows.map(row => {
+    return rows.map((row) => {
         const transformedRow = {};
         for (const [columnName, value] of Object.entries(row)) {
             const transform = transformations.get(columnName);
@@ -134,10 +136,7 @@ async function insertBatch(db, tableName, rows) {
         return;
     }
     // Use Kysely's batch insert
-    await db
-        .insertInto(tableName)
-        .values(rows)
-        .execute();
+    await db.insertInto(tableName).values(rows).execute();
 }
 /**
  * Calculate estimated time remaining
@@ -155,16 +154,16 @@ function calculateETA(startTime, completed, total) {
  * Migrate data for all tables in parallel
  */
 async function migrateAllTablesData(sourceDb, targetDb, sourceTables, targetTables, sourceDialect, targetDialect, options) {
-    const targetTableMap = new Map(targetTables.map(t => [t.name, t]));
+    const targetTableMap = new Map(targetTables.map((t) => [t.name, t]));
     const results = [];
     // Filter tables that exist in both source and target
-    const tablesToMigrate = sourceTables.filter(st => targetTableMap.has(st.name));
+    const tablesToMigrate = sourceTables.filter((st) => targetTableMap.has(st.name));
     if (options.parallel && options.parallelWorkers > 1) {
         // Migrate tables in parallel batches
         const workerCount = Math.min(options.parallelWorkers, tablesToMigrate.length);
         const chunks = chunkArray(tablesToMigrate, workerCount);
         for (const chunk of chunks) {
-            const chunkResults = await Promise.all(chunk.map(sourceTable => {
+            const chunkResults = await Promise.all(chunk.map((sourceTable) => {
                 const targetTable = targetTableMap.get(sourceTable.name);
                 return migrateTableData(sourceDb, targetDb, sourceTable, targetTable, sourceDialect, targetDialect, options);
             }));
@@ -225,6 +224,8 @@ async function truncateTable(db, tableName, dialect) {
     else {
         await sql_js_1.sql.raw(`DELETE FROM "${tableName}"`).execute(db);
         // Reset autoincrement counter in SQLite
-        await sql_js_1.sql.raw(`DELETE FROM sqlite_sequence WHERE name = '${tableName}'`).execute(db);
+        await sql_js_1.sql
+            .raw(`DELETE FROM sqlite_sequence WHERE name = '${tableName}'`)
+            .execute(db);
     }
 }

package/dist/cjs/migration/database_migration_manager.js

@@ -90,7 +90,7 @@ class DatabaseMigrationManager {
             this.logger.info('\n✅ Step 4: Verifying migration...');
             const verificationResult = await this.verifyMigration(filteredSourceSchema);
             result.warnings.push(...verificationResult.warnings);
-            result.success = result.errors.filter(e => e.fatal).length === 0;
+            result.success = result.errors.filter((e) => e.fatal).length === 0;
             result.duration = Date.now() - startTime;
             this.logger.info('\n🎉 Migration completed!');
             this.logger.info(`   Duration: ${(result.duration / 1000).toFixed(2)}s`);
@@ -146,14 +146,14 @@ class DatabaseMigrationManager {
         this.logger.info(`   Generated ${sqlStatements.length} SQL statements`);
         if (options.generateSQL) {
             this.logger.info('\nSQL Statements:');
-            sqlStatements.forEach(stmt => this.logger.info(stmt));
+            sqlStatements.forEach((stmt) => this.logger.info(stmt));
         }
         if (options.apply) {
             const result = await (0, schema_differ_js_1.applySchemaSyncronization)(this.targetDb, sqlStatements, options);
             this.logger.info(`   Applied ${result.appliedStatements} changes`);
             if (result.errors.length > 0) {
                 this.logger.error(`   Errors: ${result.errors.length}`);
-                result.errors.forEach(err => {
+                result.errors.forEach((err) => {
                     this.logger.error(`     ${err.sql}`);
                     this.logger.error(`     ${err.error.message}`);
                 });
@@ -199,11 +199,13 @@ class DatabaseMigrationManager {
      */
     filterTables(tables) {
         let filtered = tables;
-        if (this.config.options?.includeTables && this.config.options.includeTables.length > 0) {
-            filtered = filtered.filter(t => this.config.options.includeTables.includes(t.name));
+        if (this.config.options?.includeTables &&
+            this.config.options.includeTables.length > 0) {
+            filtered = filtered.filter((t) => this.config.options.includeTables.includes(t.name));
         }
-        if (this.config.options?.excludeTables && this.config.options.excludeTables.length > 0) {
-            filtered = filtered.filter(t => !this.config.options.excludeTables.includes(t.name));
+        if (this.config.options?.excludeTables &&
+            this.config.options.excludeTables.length > 0) {
+            filtered = filtered.filter((t) => !this.config.options.excludeTables.includes(t.name));
         }
         return filtered;
     }
@@ -219,9 +221,11 @@ class DatabaseMigrationManager {
         if (this.config.options?.dropTables) {
             this.logger.info('   Dropping existing tables...');
             for (const table of targetSchema) {
-                if (sourceSchema.find(t => t.name === table.name)) {
+                if (sourceSchema.find((t) => t.name === table.name)) {
                     try {
-                        await sql_js_1.sql.raw(`DROP TABLE IF EXISTS "${table.name}" CASCADE`).execute(this.targetDb);
+                        await sql_js_1.sql
+                            .raw(`DROP TABLE IF EXISTS "${table.name}" CASCADE`)
+                            .execute(this.targetDb);
                         this.logger.info(`     Dropped: ${table.name}`);
                     }
                     catch (error) {
@@ -233,7 +237,7 @@ class DatabaseMigrationManager {
         // Create tables
         for (const sourceTable of sourceSchema) {
             try {
-                const targetTable = targetSchema.find(t => t.name === sourceTable.name);
+                const targetTable = targetSchema.find((t) => t.name === sourceTable.name);
                 if (!targetTable || this.config.options?.dropTables) {
                     // Create table
                     await this.createTable(sourceTable);
@@ -292,8 +296,8 @@ class DatabaseMigrationManager {
         createSQL += columnDefs.join(',\n');
         // Add foreign keys
         for (const fk of sourceTable.foreignKeys) {
-            const fkCols = fk.columns.map(c => `"${c}"`).join(', ');
-            const refCols = fk.referencedColumns.map(c => `"${c}"`).join(', ');
+            const fkCols = fk.columns.map((c) => `"${c}"`).join(', ');
+            const refCols = fk.referencedColumns.map((c) => `"${c}"`).join(', ');
             createSQL += `,\n  FOREIGN KEY (${fkCols}) REFERENCES "${fk.referencedTable}" (${refCols})`;
             if (fk.onDelete) {
                 createSQL += ` ON DELETE ${fk.onDelete}`;
@@ -332,7 +336,7 @@ class DatabaseMigrationManager {
         const results = await (0, data_migrator_js_1.migrateAllTablesData)(this.sourceDb, this.targetDb, sourceSchema, targetSchema, this.config.source.dialect, this.config.target.dialect, options);
         const tablesProcessed = results.length;
         const rowsMigrated = results.reduce((sum, r) => sum + r.rowsMigrated, 0);
-        const errors = results.flatMap(r => r.errors);
+        const errors = results.flatMap((r) => r.errors);
         const warnings = [];
         for (const result of results) {
             if (result.errors.length > 0) {

package/dist/cjs/migration/schema_differ.js

@@ -13,8 +13,8 @@ const type_mapper_js_1 = require("./type_mapper.js");
  */
 function compareSchemas(sourceSchema, targetSchema, sourceDialect, targetDialect) {
     const differences = [];
-    const sourceTableMap = new Map(sourceSchema.map(t => [t.name, t]));
-    const targetTableMap = new Map(targetSchema.map(t => [t.name, t]));
+    const sourceTableMap = new Map(sourceSchema.map((t) => [t.name, t]));
+    const targetTableMap = new Map(targetSchema.map((t) => [t.name, t]));
     // Find added and modified tables
     for (const sourceTable of sourceSchema) {
         const targetTable = targetTableMap.get(sourceTable.name);
@@ -55,11 +55,17 @@ function compareSchemas(sourceSchema, targetSchema, sourceDialect, targetDialect
         }
     }
     // Calculate summary
-    const tablesAdded = differences.filter(d => d.type === 'table_added').length;
-    const tablesRemoved = differences.filter(d => d.type === 'table_removed').length;
+    const tablesAdded = differences.filter((d) => d.type === 'table_added').length;
+    const tablesRemoved = differences.filter((d) => d.type === 'table_removed').length;
     const tablesModified = new Set(differences
-        .filter(d => ['column_added', 'column_removed', 'column_modified', 'index_added', 'index_removed'].includes(d.type))
-        .map(d => d.table)).size;
+        .filter((d) => [
+        'column_added',
+        'column_removed',
+        'column_modified',
+        'index_added',
+        'index_removed',
+    ].includes(d.type))
+        .map((d) => d.table)).size;
     return {
         differences,
         sourceSchema,
@@ -75,8 +81,8 @@ function compareSchemas(sourceSchema, targetSchema, sourceDialect, targetDialect
 }
 function compareColumns(sourceTable, targetTable, sourceDialect, targetDialect) {
     const differences = [];
-    const sourceColumnMap = new Map(sourceTable.columns.map(c => [c.name, c]));
-    const targetColumnMap = new Map(targetTable.columns.map(c => [c.name, c]));
+    const sourceColumnMap = new Map(sourceTable.columns.map((c) => [c.name, c]));
+    const targetColumnMap = new Map(targetTable.columns.map((c) => [c.name, c]));
     // Check for added and modified columns
     for (const sourceColumn of sourceTable.columns) {
         const targetColumn = targetColumnMap.get(sourceColumn.name);
@@ -140,8 +146,8 @@ function compareColumns(sourceTable, targetTable, sourceDialect, targetDialect)
 }
 function compareIndexes(sourceTable, targetTable) {
     const differences = [];
-    const sourceIndexMap = new Map(sourceTable.indexes.map(i => [i.name, i]));
-    const targetIndexMap = new Map(targetTable.indexes.map(i => [i.name, i]));
+    const sourceIndexMap = new Map(sourceTable.indexes.map((i) => [i.name, i]));
+    const targetIndexMap = new Map(targetTable.indexes.map((i) => [i.name, i]));
     // Check for added indexes
     for (const sourceIndex of sourceTable.indexes) {
         const targetIndex = targetIndexMap.get(sourceIndex.name);
@@ -231,7 +237,8 @@ function generateSyncSQL(comparison, targetDialect) {
     return sqlStatements;
 }
 function generateCreateTableSQL(table, targetDialect) {
-    const columns = table.columns.map(col => {
+    const columns = table.columns
+        .map((col) => {
         let colDef = `"${col.name}" ${col.type}`;
         if (col.primaryKey) {
             colDef += ' PRIMARY KEY';
@@ -249,13 +256,14 @@ function generateCreateTableSQL(table, targetDialect) {
             colDef += ` DEFAULT ${col.defaultValue}`;
         }
         return colDef;
-    }).join(',\n  ');
+    })
+        .join(',\n  ');
     let sql = `CREATE TABLE "${table.name}" (\n  ${columns}`;
     // Add foreign keys
     if (table.foreignKeys.length > 0) {
         for (const fk of table.foreignKeys) {
-            const fkCols = fk.columns.map(c => `"${c}"`).join(', ');
-            const refCols = fk.referencedColumns.map(c => `"${c}"`).join(', ');
+            const fkCols = fk.columns.map((c) => `"${c}"`).join(', ');
+            const refCols = fk.referencedColumns.map((c) => `"${c}"`).join(', ');
             sql += `,\n  FOREIGN KEY (${fkCols}) REFERENCES "${fk.referencedTable}" (${refCols})`;
             if (fk.onDelete) {
                 sql += ` ON DELETE ${fk.onDelete}`;

package/dist/cjs/migration/schema_introspector.js

@@ -34,8 +34,8 @@ async function introspectSQLiteSchema(db) {
         const rowCount = countResult.rows[0]?.count || 0;
         // Get primary key
         const primaryKey = columns
-            .filter(col => col.primaryKey)
-            .map(col => col.name);
+            .filter((col) => col.primaryKey)
+            .map((col) => col.name);
         tables.push({
             name: tableName,
             columns,
@@ -120,9 +120,9 @@ async function introspectSQLiteForeignKeys(db, tableName) {
     for (const rows of fkMap.values()) {
         const first = rows[0];
         foreignKeys.push({
-            columns: rows.map(r => r.from),
+            columns: rows.map((r) => r.from),
             referencedTable: first.table,
-            referencedColumns: rows.map(r => r.to),
+            referencedColumns: rows.map((r) => r.to),
             onDelete: first.on_delete,
             onUpdate: first.on_update,
         });
@@ -177,8 +177,8 @@ async function introspectPostgreSQLSchema(db) {
         const rowCount = parseInt(countResult.rows[0]?.count || '0', 10);
         // Get primary key
         const primaryKey = columns
-            .filter(col => col.primaryKey)
-            .map(col => col.name);
+            .filter((col) => col.primaryKey)
+            .map((col) => col.name);
         tables.push({
             name: tableName,
             columns,
@@ -315,9 +315,9 @@ async function introspectPostgreSQLForeignKeys(db, tableName) {
         const first = rows[0];
         foreignKeys.push({
             name: constraintName,
-            columns: rows.map(r => r.column_name),
+            columns: rows.map((r) => r.column_name),
             referencedTable: first.foreign_table_name,
-            referencedColumns: rows.map(r => r.foreign_column_name),
+            referencedColumns: rows.map((r) => r.foreign_column_name),
             onDelete: first.delete_rule?.toUpperCase(),
             onUpdate: first.update_rule?.toUpperCase(),
         });

package/dist/cjs/migration/type_mapper.js

@@ -12,99 +12,99 @@ exports.areTypesCompatible = areTypesCompatible;
  */
 exports.SQLITE_TO_POSTGRES_TYPES = {
     // Integer types
-    'INTEGER': 'INTEGER',
-    'INT': 'INTEGER',
-    'TINYINT': 'SMALLINT',
-    'SMALLINT': 'SMALLINT',
-    'MEDIUMINT': 'INTEGER',
-    'BIGINT': 'BIGINT',
+    INTEGER: 'INTEGER',
+    INT: 'INTEGER',
+    TINYINT: 'SMALLINT',
+    SMALLINT: 'SMALLINT',
+    MEDIUMINT: 'INTEGER',
+    BIGINT: 'BIGINT',
     // Real/Float types
-    'REAL': 'REAL',
-    'DOUBLE': 'DOUBLE PRECISION',
+    REAL: 'REAL',
+    DOUBLE: 'DOUBLE PRECISION',
     'DOUBLE PRECISION': 'DOUBLE PRECISION',
-    'FLOAT': 'REAL',
+    FLOAT: 'REAL',
     // Numeric/Decimal
-    'NUMERIC': 'NUMERIC',
-    'DECIMAL': 'DECIMAL',
+    NUMERIC: 'NUMERIC',
+    DECIMAL: 'DECIMAL',
     // Text types
-    'TEXT': 'TEXT',
-    'CHARACTER': 'VARCHAR',
-    'VARCHAR': 'VARCHAR',
+    TEXT: 'TEXT',
+    CHARACTER: 'VARCHAR',
+    VARCHAR: 'VARCHAR',
     'VARYING CHARACTER': 'VARCHAR',
-    'NCHAR': 'VARCHAR',
+    NCHAR: 'VARCHAR',
     'NATIVE CHARACTER': 'VARCHAR',
-    'NVARCHAR': 'VARCHAR',
-    'CLOB': 'TEXT',
+    NVARCHAR: 'VARCHAR',
+    CLOB: 'TEXT',
     // Binary types
-    'BLOB': 'BYTEA',
+    BLOB: 'BYTEA',
     // Boolean
-    'BOOLEAN': 'BOOLEAN',
+    BOOLEAN: 'BOOLEAN',
     // Date/Time types (SQLite stores as text/integer)
-    'DATE': 'DATE',
-    'DATETIME': 'TIMESTAMP',
-    'TIMESTAMP': 'TIMESTAMP',
-    'TIME': 'TIME',
+    DATE: 'DATE',
+    DATETIME: 'TIMESTAMP',
+    TIMESTAMP: 'TIMESTAMP',
+    TIME: 'TIME',
 };
 /**
  * Map PostgreSQL types to SQLite types
  */
 exports.POSTGRES_TO_SQLITE_TYPES = {
     // Integer types
-    'INTEGER': 'INTEGER',
-    'INT': 'INTEGER',
-    'INT4': 'INTEGER',
-    'SMALLINT': 'INTEGER',
-    'INT2': 'INTEGER',
-    'BIGINT': 'INTEGER',
-    'INT8': 'INTEGER',
-    'SERIAL': 'INTEGER',
-    'BIGSERIAL': 'INTEGER',
-    'SMALLSERIAL': 'INTEGER',
+    INTEGER: 'INTEGER',
+    INT: 'INTEGER',
+    INT4: 'INTEGER',
+    SMALLINT: 'INTEGER',
+    INT2: 'INTEGER',
+    BIGINT: 'INTEGER',
+    INT8: 'INTEGER',
+    SERIAL: 'INTEGER',
+    BIGSERIAL: 'INTEGER',
+    SMALLSERIAL: 'INTEGER',
     // Float types
-    'REAL': 'REAL',
-    'FLOAT4': 'REAL',
+    REAL: 'REAL',
+    FLOAT4: 'REAL',
     'DOUBLE PRECISION': 'REAL',
-    'FLOAT8': 'REAL',
+    FLOAT8: 'REAL',
     // Numeric
-    'NUMERIC': 'NUMERIC',
-    'DECIMAL': 'NUMERIC',
+    NUMERIC: 'NUMERIC',
+    DECIMAL: 'NUMERIC',
     // Text types
-    'TEXT': 'TEXT',
-    'VARCHAR': 'TEXT',
+    TEXT: 'TEXT',
+    VARCHAR: 'TEXT',
     'CHARACTER VARYING': 'TEXT',
-    'CHAR': 'TEXT',
-    'CHARACTER': 'TEXT',
-    'BPCHAR': 'TEXT',
+    CHAR: 'TEXT',
+    CHARACTER: 'TEXT',
+    BPCHAR: 'TEXT',
     // Binary
-    'BYTEA': 'BLOB',
+    BYTEA: 'BLOB',
     // Boolean
-    'BOOLEAN': 'INTEGER',
-    'BOOL': 'INTEGER',
+    BOOLEAN: 'INTEGER',
+    BOOL: 'INTEGER',
     // Date/Time
-    'DATE': 'TEXT',
-    'TIME': 'TEXT',
-    'TIMESTAMP': 'TEXT',
-    'TIMESTAMPTZ': 'TEXT',
+    DATE: 'TEXT',
+    TIME: 'TEXT',
+    TIMESTAMP: 'TEXT',
+    TIMESTAMPTZ: 'TEXT',
     'TIMESTAMP WITH TIME ZONE': 'TEXT',
     'TIMESTAMP WITHOUT TIME ZONE': 'TEXT',
-    'INTERVAL': 'TEXT',
+    INTERVAL: 'TEXT',
     // JSON
-    'JSON': 'TEXT',
-    'JSONB': 'TEXT',
+    JSON: 'TEXT',
+    JSONB: 'TEXT',
     // UUID
-    'UUID': 'TEXT',
+    UUID: 'TEXT',
     // Network types
-    'INET': 'TEXT',
-    'CIDR': 'TEXT',
-    'MACADDR': 'TEXT',
+    INET: 'TEXT',
+    CIDR: 'TEXT',
+    MACADDR: 'TEXT',
     // Geometric types (simplified)
-    'POINT': 'TEXT',
-    'LINE': 'TEXT',
-    'LSEG': 'TEXT',
-    'BOX': 'TEXT',
-    'PATH': 'TEXT',
-    'POLYGON': 'TEXT',
-    'CIRCLE': 'TEXT',
+    POINT: 'TEXT',
+    LINE: 'TEXT',
+    LSEG: 'TEXT',
+    BOX: 'TEXT',
+    PATH: 'TEXT',
+    POLYGON: 'TEXT',
+    CIRCLE: 'TEXT',
     // Array types - convert to TEXT in SQLite
     'TEXT[]': 'TEXT',
     'INTEGER[]': 'TEXT',
@@ -116,8 +116,8 @@ exports.POSTGRES_TO_SQLITE_TYPES = {
     'JSON[]': 'TEXT',
     'JSONB[]': 'TEXT',
     // Full-text search
-    'TSVECTOR': 'TEXT',
-    'TSQUERY': 'TEXT',
+    TSVECTOR: 'TEXT',
+    TSQUERY: 'TEXT',
 };
 /**
  * Map type from source dialect to target dialect
@@ -259,5 +259,6 @@ function areTypesCompatible(sourceType, targetType, sourceDialect, targetDialect
         return sourceType.toUpperCase() === targetType.toUpperCase();
     }
     const mapped = mapType(sourceType, sourceDialect, targetDialect);
-    return mapped.toUpperCase().split('(')[0] === targetType.toUpperCase().split('(')[0];
+    return (mapped.toUpperCase().split('(')[0] ===
+        targetType.toUpperCase().split('(')[0]);
 }