masterrecord 0.3.42 → 0.3.44

package/Migrations/migrationTemplate.js

@@ -24,12 +24,12 @@ class ${this.name} extends masterrecord.schema {
     }
 
     async up(table){
-        this.init(table);
+        await this.init(table);
         ${this.#up}
     }
 
     async down(table){
-        this.init(table);
+        await this.init(table);
         ${this.#down}
     }
 }

package/Migrations/schema.js

@@ -6,15 +6,153 @@ class schema{
         this._dbEnsured = false;
     }
 
+    /**
+     * Wait for async database initialization (MySQL/PostgreSQL) to complete.
+     * The context constructor fires off an async pool init that may not have
+     * finished by the time migration methods run. This must be awaited before
+     * accessing this.context._SQLEngine or this.context.db.
+     *
+     * For MySQL: if the init fails because the database doesn't exist yet,
+     * create the database first, then retry the connection.
+     */
+    async _ensureReady(){
+        if(this.context && this.context._initPromise){
+            try{
+                await this.context._initPromise;
+            }catch(err){
+                const msg = err && (err.message || (err.context && err.context.originalError) || '');
+                const msgStr = typeof msg === 'string' ? msg : '';
+                // MySQL: "Unknown database 'X'"
+                if(this.context.isMySQL && msgStr.includes('Unknown database')){
+                    await this._createDatabaseFromConfig();
+                    await this._retryMySQLInit();
+                // PostgreSQL: 'database "X" does not exist'
+                }else if(this.context.isPostgres && msgStr.includes('does not exist')){
+                    await this._createPostgresDatabaseFromConfig();
+                    await this._retryPostgresInit();
+                }else{
+                    throw err;
+                }
+            }
+        }
+    }
+
+    /**
+     * Create MySQL database using stored config (no existing connection needed).
+     * Used when the initial connection fails because the database doesn't exist.
+     */
+    async _createDatabaseFromConfig(){
+        try{
+            const config = this.context._dbConfig;
+            if(!config || !config.database){ return; }
+            const dbName = config.database;
+            // Validate database name
+            if(!/^[a-zA-Z0-9_-]+$/.test(dbName)){
+                throw new Error(`Invalid database name: ${dbName}. Only alphanumeric characters, underscores, and hyphens are allowed.`);
+            }
+            const MySQLAsyncClient = require('masterrecord/mySQLConnect');
+            // Connect without specifying database
+            const adminConfig = { ...config };
+            delete adminConfig.database;
+            delete adminConfig.type;
+            const admin = new MySQLAsyncClient(adminConfig);
+            await admin.connect();
+            const pool = admin.getPool();
+            if(!pool){ return; }
+            // Check and create
+            const [rows] = await pool.execute(`SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = ?`, [dbName]);
+            const exists = Array.isArray(rows) && rows.length > 0;
+            if(!exists){
+                await pool.execute(`CREATE DATABASE \`${dbName}\` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`);
+                console.log(`[MySQL] Created database '${dbName}'`);
+            }
+            await admin.close();
+            this._dbEnsured = true;
+        }catch(err){
+            console.error('[MySQL] Failed to create database:', err.message);
+        }
+    }
+
+    /**
+     * Retry MySQL init after database creation.
+     * Re-runs __mysqlInit and stores the new promise.
+     */
+    async _retryMySQLInit(){
+        const config = this.context._dbConfig;
+        if(!config){ throw new Error('No MySQL config available for retry'); }
+        const MySQLEngine = require('masterrecord/mySQLEngine');
+        const MySQLAsyncClient = require('masterrecord/mySQLConnect');
+        console.log('[MySQL] Retrying connection after database creation...');
+        const client = new MySQLAsyncClient(config);
+        await client.connect();
+        const pool = client.getPool();
+        this.context._SQLEngine = new MySQLEngine();
+        this.context._SQLEngine.setDB(pool);
+        this.context._SQLEngine.__name = 'mysql2';
+        this.context.db = client;
+        console.log('[MySQL] Connection pool ready');
+    }
 
-    init(table){
+    /**
+     * Create PostgreSQL database using stored config (no existing connection needed).
+     * Used when the initial connection fails because the database doesn't exist.
+     */
+    async _createPostgresDatabaseFromConfig(){
+        try{
+            const config = this.context._dbConfig;
+            if(!config || !config.database){ return; }
+            const dbName = config.database;
+            // Validate database name
+            if(!/^[a-zA-Z0-9_-]+$/.test(dbName)){
+                throw new Error(`Invalid database name: ${dbName}. Only alphanumeric characters, underscores, and hyphens are allowed.`);
+            }
+            const { Pool } = require('pg');
+            // Connect to default 'postgres' database to run CREATE DATABASE
+            const adminConfig = {
+                host: config.host || 'localhost',
+                port: config.port || 5432,
+                user: config.user,
+                password: config.password,
+                database: 'postgres',
+                ssl: config.ssl || false
+            };
+            const adminPool = new Pool(adminConfig);
+            // Check if database exists
+            const result = await adminPool.query(`SELECT 1 FROM pg_database WHERE datname = $1`, [dbName]);
+            if(result.rows.length === 0){
+                // CREATE DATABASE cannot use parameterized queries, but name is validated above
+                await adminPool.query(`CREATE DATABASE "${dbName}" ENCODING 'UTF8'`);
+                console.log(`[PostgreSQL] Created database '${dbName}'`);
+            }
+            await adminPool.end();
+            this._dbEnsured = true;
+        }catch(err){
+            console.error('[PostgreSQL] Failed to create database:', err.message);
+        }
+    }
+
+    /**
+     * Retry PostgreSQL init after database creation.
+     */
+    async _retryPostgresInit(){
+        const config = this.context._dbConfig;
+        if(!config){ throw new Error('No PostgreSQL config available for retry'); }
+        const PostgresClient = require('masterrecord/postgresSyncConnect');
+        console.log('[PostgreSQL] Retrying connection after database creation...');
+        const connection = new PostgresClient();
+        await connection.connect(config);
+        this.context._SQLEngine = connection.getEngine();
+        this.context._SQLEngine.__name = 'pg';
+        this.context.db = connection.getPool();
+        console.log('[PostgreSQL] Connection pool ready');
+    }
+
+    async init(table){
+        // Wait for async DB init (MySQL/PostgreSQL) before any operations
+        await this._ensureReady();
         if(table){
             this.fullTable = table.___table;
         }
-        // Ensure backing database exists for MySQL before running any DDL
-        if(this.context && this.context.isMySQL && this._dbEnsured !== true){
-            try{ this.createDatabase(); }catch(_){ /* best-effort */ }
-        }
     }
     
     // create obj to convert into create sql
@@ -83,6 +221,9 @@ class schema{
     }
     
     async createTable(table){
+        // Ensure async DB init is complete (safety net for older migrations
+        // that call this.init(table) without await)
+        await this._ensureReady();
 
         if(table){
             // If table exists, run sync instead of blind create
@@ -324,38 +465,9 @@ class schema{
     }
 
     // EnsureCreated equivalent for MySQL: create DB if missing
+    // Delegates to _createDatabaseFromConfig which uses stored config
     async createDatabase(){
-        try{
-            if(!(this.context && this.context.isMySQL)){ return; }
-            const MySQLAsyncClient = require('masterrecord/mySQLConnect');
-            const client = this.context.db; // main client (may not be connected yet)
-            if(!client || !client.config || !client.config.database){ return; }
-            const dbName = client.config.database;
-            // Build server-level connection (no database)
-            const baseConfig = { ...client.config };
-            delete baseConfig.database;
-            const admin = new MySQLAsyncClient(baseConfig);
-            await admin.connect();
-            const pool = admin.getPool();
-            if(!pool){ return; }
-
-            // Use parameterized query for checking database existence
-            const [rows] = await pool.execute(`SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = ?`, [dbName]);
-            const exists = Array.isArray(rows) && rows.length > 0;
-            if(!exists){
-                // Validate database name (alphanumeric, underscore, hyphen only)
-                if(!/^[a-zA-Z0-9_-]+$/.test(dbName)){
-                    throw new Error(`Invalid database name: ${dbName}. Only alphanumeric characters, underscores, and hyphens are allowed.`);
-                }
-                // CREATE DATABASE doesn't support placeholders, but we've validated the name
-                await pool.execute(`CREATE DATABASE \`${dbName}\` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`);
-            }
-            await admin.close();
-            this._dbEnsured = true;
-        }catch(err){
-            // Non-fatal: migrations may still proceed if DB already exists or permissions blocked
-            try{ console.error(err); }catch(_){ }
-        }
+        return this._createDatabaseFromConfig();
     }
 
     // Alias for consistency with user expectation

package/context.js

@@ -711,12 +711,17 @@ class context {
                 this.isSQLite = false;
                 this.isPostgres = false;
 
+                // Store config so migration schema can create the database if it doesn't exist
+                this._dbConfig = options;
+
                 // MySQL is async - caller must await env()
-                return (async () => {
+                // Store promise so migration schema can await it
+                this._initPromise = (async () => {
                     this.db = await this.__mysqlInit(options, 'mysql2');
                     // Note: engine is already set in __mysqlInit
                     return this;
                 })();
+                return this._initPromise;
             }
 
             // PostgreSQL initialization (async)
@@ -725,12 +730,17 @@ class context {
                 this.isMySQL = false;
                 this.isSQLite = false;
 
+                // Store config so migration schema can create the database if it doesn't exist
+                this._dbConfig = options;
+
                 // PostgreSQL is async - caller must await env()
-                return (async () => {
+                // Store promise so migration schema can await it
+                this._initPromise = (async () => {
                     this.db = await this.__postgresInit(options, 'pg');
                     // Note: engine is already set in __postgresInit
                     return this;
                 })();
+                return this._initPromise;
             }
 
             throw new ConfigurationError(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "masterrecord",
-  "version": "0.3.42",
+  "version": "0.3.44",
   "description": "An Object-relational mapping for the Master framework. Master Record connects classes to relational database tables to establish a database with almost zero-configuration ",
   "main": "MasterRecord.js",
   "bin": {

package/readme.md

@@ -3369,19 +3369,37 @@ user.name = null;  // Error if name is { nullable: false }
 
 ## Changelog
 
-### Version 0.3.41 (2026-02-20) - FIX: add-migration No Longer Creates Unnecessary Database Connections
+### Version 0.3.44 (2026-02-20) - FIX: MySQL/PostgreSQL Auto-Create Database During Migrations
 
-#### Bug Fixed: `add-migration` creating real database connections and files
+#### Bug Fixed: `update-database` failing when database doesn't exist yet (MySQL & PostgreSQL)
+- **FIXED**: Running `masterrecord update-database` on a fresh MySQL or PostgreSQL server would fail because `__mysqlInit`/`__postgresInit` tried to connect to the database before it was created
+  - **Root Cause**: The `createDatabase()` method depended on `this.context.db` (the connected client) to get config, but the client connection failed because the database didn't exist — a chicken-and-egg problem
+  - **Solution**: Store config as `this._dbConfig` on the context before async init. `_ensureReady()` now catches database-not-found errors (MySQL: "Unknown database", PostgreSQL: "does not exist"), creates the database using a server-level connection, then retries the full init
+  - **Impact**: `update-database` now automatically creates the database if it doesn't exist for all three engines (SQLite, MySQL, PostgreSQL)
+
+#### Files Modified
+1. **`context.js`** - Store `_dbConfig` before async MySQL and PostgreSQL init
+2. **`Migrations/schema.js`** - Added `_createDatabaseFromConfig()`, `_retryMySQLInit()`, `_createPostgresDatabaseFromConfig()`, `_retryPostgresInit()`, updated `_ensureReady()` to handle missing database for both engines
+
+### Version 0.3.42 (2026-02-20) - FIX: Migration System + add-migration Improvements
+
+#### Bug Fixed: `update-database` failing for MySQL/PostgreSQL with "Cannot read properties of null"
+- **FIXED**: Running `masterrecord update-database` with MySQL or PostgreSQL would crash with `Cannot read properties of null (reading 'tableExists')`
+  - **Root Cause**: The migration `schema.js` constructor creates a new context instance, but MySQL/PostgreSQL database initialization is async. The `_SQLEngine` property was still `null` when `createTable` tried to use it because the async pool init hadn't completed yet.
+  - **Solution**: Store the async init promise as `_initPromise` on the context instance. Added `_ensureReady()` method to `schema.js` that awaits it. Called in both `init()` and `createTable()` (safety net for existing migrations).
+  - **Also fixed**: Typo in `schema.js` — `require('masterrecord/mySQLAsyncConnect')` corrected to `require('masterrecord/mySQLConnect')`
+  - **Also fixed**: `init()` now properly `await`s `createDatabase()` instead of fire-and-forget
+
+#### Bug Fixed: `add-migration` creating unnecessary database connections
 - **FIXED**: Running `masterrecord add-migration` would open a real database connection (creating SQLite files on disk, or connecting to MySQL/PostgreSQL) even though it only needs entity schemas and seed data to generate migration files
-  - **Problem**: On production servers, `add-migration` created unwanted `.sqlite3` files and printed misleading "SQLite database closed" messages
-  - **Root Cause**: The context constructor calls `env()` which initializes a full database connection; `add-migration` only needs entity metadata
-  - **Solution**: Added schema-only mode (`MASTERRECORD_SCHEMA_ONLY` env var) that sets database type flags for correct entity registration but skips all database initialization (no file creation, no connections)
-  - **Impact**: `add-migration` is now faster, creates no side effects, and works safely on production servers
+  - **Solution**: Added schema-only mode (`MASTERRECORD_SCHEMA_ONLY` env var) that sets database type flags but skips all DB initialization
 
 #### Files Modified
-1. **`Migrations/cli.js`** - Set `MASTERRECORD_SCHEMA_ONLY=1` before context construction, removed unnecessary `close()` calls
-2. **`context.js`** - Added schema-only mode check in `env()` that returns early after setting type flags
-3. **`package.json`** - Updated to v0.3.41
+1. **`Migrations/schema.js`** - Added `_ensureReady()`, made `init()` async with proper awaits, fixed `mySQLConnect` require
+2. **`Migrations/migrationTemplate.js`** - New migrations now `await this.init(table)`
+3. **`Migrations/cli.js`** - Schema-only mode for `add-migration`
+4. **`context.js`** - Store `_initPromise` for MySQL/PostgreSQL async init, schema-only mode in `env()`
+5. **`package.json`** - Updated to v0.3.42
 
 ### Version 0.3.39 (2026-02-09) - CRITICAL BUG FIX: Foreign Key String Values