noormme 1.0.6 → 1.2.0

package/dist/esm/index.js

@@ -2,7 +2,7 @@
 export * from './kysely.js';
 export * from './query-creator.js';
 export * from './expression/expression.js';
-export { expressionBuilder, } from './expression/expression-builder.js';
+export { expressionBuilder } from './expression/expression-builder.js';
 export * from './expression/expression-wrapper.js';
 export * from './query-builder/where-interface.js';
 export * from './query-builder/returning-interface.js';
@@ -236,7 +236,7 @@ export * from './agentic/CognitiveRepository.js';
 export * from './helpers/agent-schema.js';
 export * from './helpers/schema-evolution.js';
 // Error classes
-export { NoormError, TableNotFoundError, ColumnNotFoundError, ConnectionError, DatabaseInitializationError, ValidationError, RelationshipNotFoundError, QueryExecutionError, SchemaDiscoveryError, MigrationError, TypeGenerationError } from './errors/NoormError.js';
+export { NoormError, TableNotFoundError, ColumnNotFoundError, ConnectionError, DatabaseInitializationError, ValidationError, RelationshipNotFoundError, QueryExecutionError, SchemaDiscoveryError, MigrationError, TypeGenerationError, } from './errors/NoormError.js';
 // CLI commands (for programmatic usage)
 export * from './cli/commands/init.js';
 export * from './cli/commands/inspect.js';

package/dist/esm/logging/logger.js

@@ -70,7 +70,7 @@ export class Logger {
             sql,
             parameters,
             duration,
-            timestamp: Date.now()
+            timestamp: Date.now(),
         };
         this.queryLogs.push(queryLog);
         this.queryCount++;
@@ -118,7 +118,7 @@ export class Logger {
      * Get slow queries
      */
     getSlowQueries(threshold = 1000) {
-        return this.queryLogs.filter(log => log.duration > threshold);
+        return this.queryLogs.filter((log) => log.duration > threshold);
     }
     /**
      * Clear query logs
@@ -162,7 +162,11 @@ export class Logger {
             const prefix = this.getPrefix(level);
             let logMessage = `[${timestamp}] ${prefix} ${message}`;
             if (args.length > 0) {
-                logMessage += ' ' + args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
+                logMessage +=
+                    ' ' +
+                        args
+                            .map((arg) => typeof arg === 'object' ? JSON.stringify(arg) : String(arg))
+                            .join(' ');
             }
             logMessage += '\n';
             fs.appendFileSync(this.config.file, logMessage);
@@ -187,7 +191,7 @@ export class Logger {
             queryCount: this.queryCount,
             averageQueryTime: this.getAverageQueryTime(),
             totalQueryTime: this.totalQueryTime,
-            slowQueries: this.getSlowQueries().length
+            slowQueries: this.getSlowQueries().length,
         };
     }
     /**

package/dist/esm/migration/data_migrator.js

@@ -22,7 +22,9 @@ export async function migrateTableData(sourceDb, targetDb, sourceTable, targetTa
             };
         }
         // 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);
@@ -103,7 +105,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 = getValueTransformation(sourceColumn.type, targetColumn.type, sourceDialect, targetDialect);
             if (transform) {
@@ -112,7 +114,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);
@@ -129,10 +131,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
@@ -150,16 +149,16 @@ function calculateETA(startTime, completed, total) {
  * Migrate data for all tables in parallel
  */
 export 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);
             }));
@@ -220,6 +219,8 @@ export async function truncateTable(db, tableName, dialect) {
     else {
         await sql.raw(`DELETE FROM "${tableName}"`).execute(db);
         // Reset autoincrement counter in SQLite
-        await sql.raw(`DELETE FROM sqlite_sequence WHERE name = '${tableName}'`).execute(db);
+        await sql
+            .raw(`DELETE FROM sqlite_sequence WHERE name = '${tableName}'`)
+            .execute(db);
     }
 }

package/dist/esm/migration/database_migration_manager.js

@@ -8,7 +8,7 @@
  * - Schema diff and sync
  */
 import { Logger } from '../logging/logger.js';
-import { introspectSQLiteSchema, introspectPostgreSQLSchema } from './schema_introspector.js';
+import { introspectSQLiteSchema, introspectPostgreSQLSchema, } from './schema_introspector.js';
 import { compareSchemas, generateSyncSQL, applySchemaSyncronization, } from './schema_differ.js';
 import { migrateAllTablesData, verifyDataMigration, } from './data_migrator.js';
 import { mapType } from './type_mapper.js';
@@ -87,7 +87,7 @@ export 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`);
@@ -143,14 +143,14 @@ export 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 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}`);
                 });
@@ -196,11 +196,13 @@ export 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;
     }
@@ -216,9 +218,11 @@ export 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.raw(`DROP TABLE IF EXISTS "${table.name}" CASCADE`).execute(this.targetDb);
+                        await sql
+                            .raw(`DROP TABLE IF EXISTS "${table.name}" CASCADE`)
+                            .execute(this.targetDb);
                         this.logger.info(`     Dropped: ${table.name}`);
                     }
                     catch (error) {
@@ -230,7 +234,7 @@ export 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);
@@ -289,8 +293,8 @@ export 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}`;
@@ -329,7 +333,7 @@ export class DatabaseMigrationManager {
         const results = await 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/esm/migration/schema_differ.js

@@ -9,8 +9,8 @@ import { areTypesCompatible } from './type_mapper.js';
  */
 export 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);
@@ -51,11 +51,17 @@ export function compareSchemas(sourceSchema, targetSchema, sourceDialect, target
         }
     }
     // 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,
@@ -71,8 +77,8 @@ export function compareSchemas(sourceSchema, targetSchema, sourceDialect, target
 }
 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);
@@ -136,8 +142,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);
@@ -227,7 +233,8 @@ export 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';
@@ -245,13 +252,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/esm/migration/schema_introspector.js

@@ -31,8 +31,8 @@ export 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,
@@ -117,9 +117,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,
         });
@@ -174,8 +174,8 @@ export 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,
@@ -312,9 +312,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/esm/migration/type_mapper.js

@@ -7,99 +7,99 @@
  */
 export const 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
  */
 export const 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',
@@ -111,8 +111,8 @@ export const 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
@@ -254,5 +254,6 @@ export function areTypesCompatible(sourceType, targetType, sourceDialect, target
         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]);
 }