nanodb-orm 0.0.3 → 0.0.5

package/dist/utils/migrations.js

@@ -1,457 +1,255 @@
 "use strict";
-/**
- * Completely Generic Database Migration Utilities
- * Uses Drizzle to auto-create tables from schema
- * No hardcoded table names or structures - completely dynamic!
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseMigrations = void 0;
 const drizzle_orm_1 = require("drizzle-orm");
 const connection_1 = require("../core/connection");
 const logger_1 = require("./logger");
-const errors_1 = require("../types/errors");
 const error_handler_1 = require("./error-handler");
 const transactions_1 = require("./transactions");
-class DatabaseMigrations {
-    /**
-     * Initialize with schema data
-     */
-    static initialize(schemaData) {
-        this.tables = schemaData.tables;
-        this.migrationConfig = {
-            preserveData: true, // Always preserve data by default
-            autoMigrate: true, // Default to auto-migration
-            dropTables: false, // Default to not dropping tables
-            ...schemaData.migrationConfig, // Override with any provided config
-        };
-    }
-    /**
-     * Initialize database schema using Drizzle's auto table creation
-     * Completely generic - works with any table structure defined in schema.ts
-     */
-    static async initializeSchema() {
-        return error_handler_1.ErrorHandler.wrapAsync(async () => {
-            logger_1.logger.info('Auto-creating database schema using Drizzle...');
-            const db = await connection_1.DatabaseConnection.getInstance();
-            // Get all tables from the provided schema
-            const tableNames = Object.keys(this.tables);
-            logger_1.logger.info(`Found ${tableNames.length} tables in schema: ${tableNames.join(', ')}`);
-            // Use Drizzle to auto-create tables
-            for (const tableName of tableNames) {
-                await this.createTableWithDrizzle(tableName, db);
-            }
-            logger_1.logger.info('Database schema initialization completed!');
-        }, {
-            operation: 'init-schema',
-            context: 'Schema initialization failed'
-        });
-    }
-    /**
-     * Create a table using Drizzle's table definition
-     * Uses the actual Drizzle table object to ensure correct SQL generation
-     */
-    static async createTableWithDrizzle(tableName, db) {
-        try {
-            const table = this.tables[tableName];
-            if (!table) {
-                throw new Error(`Table ${tableName} not found in provided schema`);
-            }
-            logger_1.logger.info(`Creating table ${tableName} using Drizzle definition`);
-            // Check if table exists and has correct schema
-            try {
-                const hasCorrectSchema = await this.validateTableSchema(tableName, table, db);
-                if (!hasCorrectSchema) {
-                    if (!this.migrationConfig.autoMigrate) {
-                        logger_1.logger.warn(`Table ${tableName} needs schema update but auto-migration is disabled`);
-                        return;
-                    }
-                    const hasData = await this.tableHasData(tableName, db);
-                    if (hasData && this.migrationConfig.preserveData && !this.migrationConfig.dropTables) {
-                        logger_1.logger.warn(`Table ${tableName} has data and preserveData is enabled. Skipping schema update.`);
-                        logger_1.logger.warn(`To update schema, set dropTables: true or preserveData: false in migration config`);
-                        return;
-                    }
-                    if (hasData) {
-                        logger_1.logger.info(`Table ${tableName} has data but will be recreated due to configuration`);
-                    }
-                    logger_1.logger.info(`Table ${tableName} needs schema update, recreating...`);
-                    // Use transaction to ensure atomic table recreation
-                    const result = await transactions_1.TransactionManager.recreateTable(tableName, async (db) => {
-                        const basicCreateSql = this.generateBasicCreateSql(tableName, table);
-                        await db.run(basicCreateSql);
-                    });
-                    if (!result.success) {
-                        throw new errors_1.DatabaseError(`Failed to recreate table ${tableName}: ${result.error?.message}`, 'recreate-table', result.error);
-                    }
-                    logger_1.logger.info(`Table ${tableName} recreated with correct schema`);
-                }
-                else {
-                    logger_1.logger.info(`Table ${tableName} already has correct schema`);
-                }
-            }
-            catch (error) {
-                error_handler_1.ErrorHandler.handleError(error, {
-                    operation: 'create-table',
-                    context: `Error ensuring table ${tableName}`
-                });
-            }
-        }
-        catch (error) {
-            error_handler_1.ErrorHandler.handleError(error, {
-                operation: 'create-table',
-                context: `Failed to create table ${tableName}`
-            });
-        }
-    }
-    /**
-     * Validate if table exists and has the correct schema
-     */
-    static async validateTableSchema(tableName, table, db) {
-        try {
-            // First check if table exists
-            const checkResult = await db.run((0, drizzle_orm_1.sql) `
-        SELECT name FROM sqlite_master 
-        WHERE type='table' AND name=${tableName}
-      `);
-            if (!checkResult.rows || checkResult.rows.length === 0) {
-                logger_1.logger.info(`Table ${tableName} does not exist, needs creation`);
-                return false;
-            }
-            // Get expected columns from the Drizzle table
-            const expectedColumns = this.getExpectedColumns(table);
-            // Get actual columns from the database
-            const actualColumns = await this.getActualColumns(tableName, db);
-            logger_1.logger.info(`Expected columns for ${tableName}:`, expectedColumns);
-            logger_1.logger.info(`Actual columns for ${tableName}:`, actualColumns);
-            // Check if all expected columns exist
-            for (const expectedCol of expectedColumns) {
-                if (!actualColumns.includes(expectedCol)) {
-                    logger_1.logger.info(`Table ${tableName} missing column: ${expectedCol}`);
-                    return false;
-                }
-            }
-            // Check if there are extra columns that shouldn't exist
-            for (const actualCol of actualColumns) {
-                if (!expectedColumns.includes(actualCol)) {
-                    logger_1.logger.info(`Table ${tableName} has extra column that should be removed: ${actualCol}`);
-                    return false;
-                }
-            }
-            return true;
-        }
-        catch (error) {
-            error_handler_1.ErrorHandler.handleNonThrowingError(error, 'validate-schema', `Error validating schema for table ${tableName}`);
-            return false; // If we can't validate, assume it needs recreation
-        }
-    }
-    /**
-     * Get expected column names from Drizzle table definition
-     */
-    static getExpectedColumns(table) {
-        const columns = {};
-        // Use the same logic as generateBasicCreateSql
-        if (table._ && table._.columns) {
-            Object.assign(columns, table._.columns);
-        }
-        else if (table.columns) {
-            Object.assign(columns, table.columns);
-        }
-        else {
-            const tableKeys = Object.keys(table).filter(key => !key.startsWith('_') &&
-                typeof table[key] === 'object' &&
-                table[key] !== null &&
-                !Array.isArray(table[key]));
-            for (const key of tableKeys) {
-                columns[key] = table[key];
-            }
-        }
-        const expectedColumns = [];
-        for (const [colName, column] of Object.entries(columns)) {
-            const col = column;
-            const dbColumnName = col.name || col.columnName || colName;
-            expectedColumns.push(dbColumnName);
-        }
-        return expectedColumns;
-    }
-    /**
-     * Get actual column names from database table
-     */
-    static async getActualColumns(tableName, db) {
-        try {
-            const result = await db.run((0, drizzle_orm_1.sql) `PRAGMA table_info(${drizzle_orm_1.sql.identifier(tableName)})`);
-            if (result.rows) {
-                return result.rows.map((row) => row.name);
-            }
-            return [];
-        }
-        catch (error) {
-            error_handler_1.ErrorHandler.handleNonThrowingError(error, 'get-table-info', `Error getting table info for ${tableName}`);
-            return [];
-        }
-    }
-    /**
-     * Check if table has any data
-     */
-    static async tableHasData(tableName, db) {
-        try {
-            const result = await db.run((0, drizzle_orm_1.sql) `SELECT COUNT(*) as count FROM ${drizzle_orm_1.sql.identifier(tableName)}`);
-            if (result.rows && result.rows.length > 0) {
-                const count = result.rows[0].count;
-                return count > 0;
-            }
-            return false;
-        }
-        catch (error) {
-            error_handler_1.ErrorHandler.handleNonThrowingError(error, 'check-table-data', `Error checking data for table ${tableName}`);
-            return false; // If we can't check, assume no data
-        }
-    }
-    /**
-     * Generate basic CREATE TABLE SQL for SQLite
-     * This is a simplified approach that works for most common table structures
-     */
-    static generateBasicCreateSql(tableName, table) {
-        try {
-            // Extract column information from Drizzle table with multiple fallback options
-            let columns = {};
-            if (table._ && table._.columns) {
-                columns = table._.columns;
-            }
-            else if (table.columns) {
-                columns = table.columns;
-            }
-            else {
-                // Try to extract columns directly from the table object
-                const tableKeys = Object.keys(table).filter(key => !key.startsWith('_') &&
-                    typeof table[key] === 'object' &&
-                    table[key] !== null &&
-                    !Array.isArray(table[key]));
-                for (const key of tableKeys) {
-                    columns[key] = table[key];
-                }
-            }
-            const columnDefs = [];
-            const foreignKeys = [];
-            for (const [colName, column] of Object.entries(columns)) {
-                const col = column;
-                // Extract the actual database column name from the Drizzle column
-                const dbColumnName = col.name || col.columnName || colName;
-                let columnDef = `"${dbColumnName}"`;
-                // Determine column type
-                if (col.dataType === 'integer' || col.columnType === 'SQLiteInteger' || col.type === 'integer') {
-                    columnDef += ' INTEGER';
-                }
-                else if (col.dataType === 'real' || col.columnType === 'SQLiteReal' || col.type === 'real') {
-                    columnDef += ' REAL';
-                }
-                else if (col.dataType === 'text' || col.columnType === 'SQLiteText' || col.type === 'text') {
-                    columnDef += ' TEXT';
-                }
-                else {
-                    columnDef += ' TEXT';
-                }
-                // Add constraints
-                if (col.primary) {
-                    columnDef += ' PRIMARY KEY';
-                    // Add AUTOINCREMENT for primary key if specified
-                    if (col.autoIncrement) {
-                        columnDef += ' AUTOINCREMENT';
-                    }
-                }
-                if (col.notNull) {
-                    columnDef += ' NOT NULL';
-                }
-                if (col.unique) {
-                    columnDef += ' UNIQUE';
-                }
-                if (col.default !== undefined) {
-                    if (typeof col.default === 'string') {
-                        columnDef += ` DEFAULT '${col.default}'`;
-                    }
-                    else if (col.default?.sql) {
-                        // Handle SQL expressions like sql`(datetime('now'))`
-                        columnDef += ` DEFAULT ${col.default.sql}`;
-                    }
-                    else if (col.default?.name === 'sql') {
-                        columnDef += ` DEFAULT ${col.default.value}`;
-                    }
-                    else if (typeof col.default === 'number') {
-                        columnDef += ` DEFAULT ${col.default}`;
-                    }
-                    else {
-                        columnDef += ` DEFAULT ${col.default}`;
-                    }
-                }
-                columnDefs.push(columnDef);
-                // Handle foreign key references
-                if (col.references) {
-                    const foreignTable = col.references.table || col.references.foreignTable?.tableName || 'unknown';
-                    const foreignColumn = col.references.column || col.references.columnName || 'id';
-                    const onDelete = col.references.onDelete || 'CASCADE';
-                    foreignKeys.push(`FOREIGN KEY ("${dbColumnName}") REFERENCES "${foreignTable}"("${foreignColumn}") ON DELETE ${onDelete}`);
-                }
-            }
-            // Combine column definitions and foreign keys
-            const allConstraints = [...columnDefs, ...foreignKeys];
-            return `CREATE TABLE IF NOT EXISTS "${tableName}" (
-      ${allConstraints.join(',\n      ')}
-    )`;
-        }
-        catch (error) {
-            error_handler_1.ErrorHandler.handleError(error, {
-                operation: 'generate-sql',
-                context: `Error generating SQL for table ${tableName}`
-            });
-            return ''; // This will never be reached due to handleError throwing
-        }
-    }
-    /**
-     * Drop all tables
-     * Uses the provided schema tables
-     */
-    static async dropAllTables() {
-        return error_handler_1.ErrorHandler.wrapAsync(async () => {
-            logger_1.logger.warn('Dropping all tables...');
+// ============================================================================
+// Module State
+// ============================================================================
+let tables = {};
+let config = {
+    preserveData: true,
+    autoMigrate: true,
+    dropTables: false,
+};
+// ============================================================================
+// Public API
+// ============================================================================
+exports.DatabaseMigrations = {
+    /** Initialize with schema data */
+    initialize(data) {
+        tables = data.tables;
+        config = { ...config, ...data.migrationConfig };
+    },
+    /** Create all tables from schema */
+    async initializeSchema() {
+        return (0, error_handler_1.withErrorHandling)('init-schema', async () => {
             const db = await connection_1.DatabaseConnection.getInstance();
-            // Get all tables from provided schema
-            const tableNames = Object.keys(this.tables);
-            // Use transaction to ensure atomic table dropping
-            const result = await transactions_1.TransactionManager.execute(async (db) => {
-                // Drop tables in reverse order to handle foreign key constraints
-                const reversedTableNames = [...tableNames].reverse();
-                for (const tableName of reversedTableNames) {
-                    await db.run(`DROP TABLE IF EXISTS ${tableName}`);
-                    logger_1.logger.info(`Dropped table ${tableName}`);
-                }
-            });
-            if (!result.success) {
-                throw new errors_1.DatabaseError(`Failed to drop tables: ${result.error?.message}`, 'drop-tables', result.error);
-            }
-            logger_1.logger.info('All tables dropped successfully');
-        }, {
-            operation: 'drop-tables',
-            context: 'Drop tables failed'
+            const tableNames = Object.keys(tables);
+            logger_1.logger.info(`Initializing ${tableNames.length} tables...`);
+            for (const name of tableNames) {
+                const table = tables[name];
+                if (table)
+                    await ensureTable(name, table, db);
+            }
+            logger_1.logger.info('Schema initialization complete');
         });
-    }
-    /**
-     * Reset database (drop and recreate all tables)
-     * Completely generic - works with any table structure defined in schema.ts
-     */
-    static async resetDatabase() {
-        try {
+    },
+    /** Drop all tables and recreate */
+    async resetDatabase() {
+        return (0, error_handler_1.withErrorHandling)('reset-db', async () => {
             logger_1.logger.warn('Resetting database...');
             await this.dropAllTables();
             await this.initializeSchema();
-            logger_1.logger.info('Database reset completed');
-        }
-        catch (error) {
-            error_handler_1.ErrorHandler.handleError(error, {
-                operation: 'reset-db',
-                context: 'Database reset failed'
-            });
-        }
-    }
-    /**
-     * Check if tables exist in the database
-     * Uses the provided schema tables
-     */
-    static async checkTableExistence() {
-        try {
+        });
+    },
+    /** Drop all tables */
+    async dropAllTables() {
+        return (0, error_handler_1.withErrorHandling)('drop-tables', async () => {
             const db = await connection_1.DatabaseConnection.getInstance();
-            const tableNames = Object.keys(this.tables);
-            const existence = {};
-            for (const tableName of tableNames) {
-                try {
-                    // Check if table exists by querying sqlite_master
-                    const result = await db.run((0, drizzle_orm_1.sql) `
-            SELECT name FROM sqlite_master 
-            WHERE type='table' AND name=${tableName}
-          `);
-                    existence[tableName] = (result.rows && result.rows.length > 0);
-                }
-                catch (error) {
-                    error_handler_1.ErrorHandler.handleOptionalError(error, 'check-table-existence', `Could not check existence of table ${tableName}`);
-                    existence[tableName] = false;
-                }
+            const tableNames = Object.keys(tables).reverse();
+            for (const name of tableNames) {
+                await db.run((0, drizzle_orm_1.sql) `DROP TABLE IF EXISTS ${drizzle_orm_1.sql.identifier(name)}`);
+                logger_1.logger.debug(`Dropped: ${name}`);
             }
-            return existence;
-        }
-        catch (error) {
-            error_handler_1.ErrorHandler.handleNonThrowingError(error, 'check-table-existence', 'Error checking table existence');
-            return {};
-        }
-    }
-    /**
-     * Validate that database schema matches provided schema
-     * Uses the provided schema tables
-     */
-    static async validateSchema() {
+        });
+    },
+    /** Check which tables exist */
+    async checkTableExistence() {
+        const db = await connection_1.DatabaseConnection.getInstance();
+        const result = {};
+        for (const name of Object.keys(tables)) {
+            result[name] = await tableExists(name, db);
+        }
+        return result;
+    },
+    /** Validate schema matches database */
+    async validateSchema() {
         try {
-            const tableNames = Object.keys(this.tables);
             const existence = await this.checkTableExistence();
-            const missingTables = [];
-            const extraTables = [];
-            const errors = [];
-            // Check for missing tables
-            for (const tableName of tableNames) {
-                if (!existence[tableName]) {
-                    missingTables.push(tableName);
-                }
-            }
-            // Check for extra tables (tables in DB but not in schema.ts)
-            // This would require querying the database for all tables
-            // For now, we'll focus on missing tables
-            const isValid = missingTables.length === 0 && errors.length === 0;
+            const expected = Object.keys(tables);
+            const missingTables = expected.filter((t) => !existence[t]);
             return {
-                isValid,
+                isValid: missingTables.length === 0,
                 missingTables,
-                extraTables,
-                errors
+                extraTables: [],
+                errors: [],
             };
         }
         catch (error) {
-            error_handler_1.ErrorHandler.handleNonThrowingError(error, 'validate-schema', 'Error validating schema');
+            (0, error_handler_1.logError)('validate-schema', error);
             return {
                 isValid: false,
                 missingTables: [],
                 extraTables: [],
-                errors: [error.message]
+                errors: [error instanceof Error ? error.message : String(error)],
             };
         }
+    },
+};
+// ============================================================================
+// Internal Functions
+// ============================================================================
+async function ensureTable(name, table, db) {
+    const exists = await tableExists(name, db);
+    const expectedCols = getColumnNames(table);
+    if (!exists) {
+        logger_1.logger.info(`Creating table: ${name}`);
+        await db.run(drizzle_orm_1.sql.raw(generateCreateSql(name, table)));
+        return;
     }
-    /**
-     * Get migration status
-     * Uses the provided schema tables
-     */
-    static async getMigrationStatus() {
-        try {
-            const tableNames = Object.keys(this.tables);
-            const existence = await this.checkTableExistence();
-            const missingTables = tableNames.filter(name => !existence[name]);
-            const isValid = missingTables.length === 0;
-            return {
-                tablesInSchema: tableNames,
-                tablesInDatabase: existence,
-                missingTables,
-                isValid
+    const actualCols = await getActualColumns(name, db);
+    const schemaMatches = columnsMatch(expectedCols, actualCols);
+    if (schemaMatches) {
+        logger_1.logger.debug(`Table ${name} is up to date`);
+        return;
+    }
+    if (!config.autoMigrate) {
+        logger_1.logger.warn(`Table ${name} needs update but auto-migrate is disabled`);
+        return;
+    }
+    const hasData = await tableHasData(name, db);
+    if (hasData && config.preserveData && !config.dropTables) {
+        logger_1.logger.warn(`Table ${name} has data, skipping update (set dropTables: true to force)`);
+        return;
+    }
+    logger_1.logger.info(`Recreating table: ${name}`);
+    const result = await (0, transactions_1.recreateTable)(name, generateCreateSql(name, table));
+    if (!result.success) {
+        throw result.error;
+    }
+}
+async function tableExists(name, db) {
+    try {
+        const result = await db.run((0, drizzle_orm_1.sql) `
+      SELECT 1 FROM sqlite_master WHERE type='table' AND name=${name}
+    `);
+        return (result.rows?.length ?? 0) > 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function tableHasData(name, db) {
+    try {
+        const result = await db.run((0, drizzle_orm_1.sql) `SELECT COUNT(*) as c FROM ${drizzle_orm_1.sql.identifier(name)}`);
+        const row = result.rows?.[0];
+        const count = row ? row.c : 0;
+        return (count ?? 0) > 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function getActualColumns(name, db) {
+    try {
+        const result = await db.run((0, drizzle_orm_1.sql) `PRAGMA table_info(${drizzle_orm_1.sql.identifier(name)})`);
+        return result.rows?.map((r) => r.name) ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+function getColumnNames(table) {
+    const cols = extractColumns(table);
+    return Object.keys(cols);
+}
+/**
+ * Extract column information from a Drizzle table.
+ * Handles both real Drizzle tables and simple objects.
+ */
+function extractColumns(table) {
+    const cols = {};
+    for (const [key, val] of Object.entries(table)) {
+        if (key.startsWith('_') || key === 'Symbol(drizzle:Name)')
+            continue;
+        if (typeof val !== 'object' || val === null)
+            continue;
+        const column = val;
+        // Check if it's a Drizzle column (has .name property that's a string)
+        const columnName = typeof column.name === 'string' ? column.name : key;
+        if (!column.name && !column.dataType)
+            continue;
+        // Determine SQL type
+        let dataType = 'TEXT';
+        const rawType = column.dataType ?? column.columnType ?? '';
+        const sqliteType = column.getSQLType?.() ?? '';
+        if (rawType.includes('integer') || sqliteType.includes('integer')) {
+            dataType = 'INTEGER';
+        }
+        else if (rawType.includes('real') || sqliteType.includes('real')) {
+            dataType = 'REAL';
+        }
+        else if (rawType.includes('blob') || sqliteType.includes('blob')) {
+            dataType = 'BLOB';
+        }
+        const info = {
+            name: columnName,
+            dataType,
+            isPrimary: column.primary === true || column.primaryKey === true,
+            hasAutoIncrement: column.autoIncrement === true || column.hasAutoIncrement === true,
+            isNotNull: column.notNull === true || column.isNotNull === true,
+            isUnique: column.unique === true || column.isUnique === true,
+            defaultValue: column.default ?? column.defaultValue,
+        };
+        if (column.references) {
+            const ref = column.references;
+            info.references = {
+                table: ref.table ?? ref.foreignTable?.tableName ?? 'unknown',
+                column: ref.column ?? ref.columnName ?? 'id',
+                onDelete: ref.onDelete ?? 'CASCADE',
             };
         }
-        catch (error) {
-            error_handler_1.ErrorHandler.handleNonThrowingError(error, 'get-migration-status', 'Error getting migration status');
-            return {
-                tablesInSchema: [],
-                tablesInDatabase: {},
-                missingTables: [],
-                isValid: false
-            };
+        cols[columnName] = info;
+    }
+    return cols;
+}
+function columnsMatch(expected, actual) {
+    if (expected.length !== actual.length)
+        return false;
+    const sortedExpected = [...expected].sort();
+    const sortedActual = [...actual].sort();
+    return sortedExpected.every((col, i) => col === sortedActual[i]);
+}
+function generateCreateSql(tableName, table) {
+    const cols = extractColumns(table);
+    const columnDefs = [];
+    const foreignKeys = [];
+    for (const [colName, info] of Object.entries(cols)) {
+        const parts = [`"${colName}"`, info.dataType];
+        if (info.isPrimary) {
+            parts.push('PRIMARY KEY');
+            if (info.hasAutoIncrement)
+                parts.push('AUTOINCREMENT');
+        }
+        if (info.isNotNull && !info.isPrimary)
+            parts.push('NOT NULL');
+        if (info.isUnique)
+            parts.push('UNIQUE');
+        // Default value
+        if (info.defaultValue !== undefined) {
+            const defaultVal = info.defaultValue;
+            if (typeof defaultVal === 'string') {
+                parts.push(`DEFAULT '${defaultVal}'`);
+            }
+            else if (typeof defaultVal === 'number') {
+                parts.push(`DEFAULT ${defaultVal}`);
+            }
+            else if (typeof defaultVal === 'object' && defaultVal !== null && 'sql' in defaultVal) {
+                parts.push(`DEFAULT ${defaultVal.sql}`);
+            }
+        }
+        columnDefs.push(parts.join(' '));
+        // Foreign key
+        if (info.references) {
+            const { table: refTable, column: refCol, onDelete } = info.references;
+            foreignKeys.push(`FOREIGN KEY ("${colName}") REFERENCES "${refTable}"("${refCol}") ON DELETE ${onDelete}`);
         }
     }
+    const allDefs = [...columnDefs, ...foreignKeys].join(',\n  ');
+    return `CREATE TABLE IF NOT EXISTS "${tableName}" (\n  ${allDefs}\n)`;
 }
-exports.DatabaseMigrations = DatabaseMigrations;
-DatabaseMigrations.tables = {};
-DatabaseMigrations.migrationConfig = {
-    preserveData: true,
-    autoMigrate: true,
-    dropTables: false,
-};
 //# sourceMappingURL=migrations.js.map