masterrecord 0.3.64 → 0.3.66

package/Migrations/schema.js

@@ -6,6 +6,12 @@ class schema{
         this._dbEnsured = false;
     }
 
+    _poolKey(type, cfg) {
+        const host = cfg.host || 'localhost';
+        const port = cfg.port || (type === 'mysql' ? 3306 : 5432);
+        return `${type}:${cfg.user}@${host}:${port}/${cfg.database}`;
+    }
+
     /**
      * Wait for async database initialization (MySQL/PostgreSQL) to complete.
      * The context constructor fires off an async pool init that may not have
@@ -84,6 +90,26 @@ class schema{
         if(!config){ throw new Error('No MySQL config available for retry'); }
         const MySQLEngine = require('masterrecord/mySQLEngine');
         const MySQLAsyncClient = require('masterrecord/mySQLConnect');
+
+        // Check global pool cache first -- another context may have already retried
+        const _pools = global.__MR_POOLS__;
+        const key = _pools ? this._poolKey('mysql', config) : null;
+
+        if (_pools && key && _pools.has(key)) {
+            const cached = _pools.get(key);
+            cached.refCount++;
+            if (cached.promise) {
+                const result = await cached.promise;
+                this.context._SQLEngine = result.engine;
+                this.context.db = result.client;
+            } else {
+                this.context._SQLEngine = cached.engine;
+                this.context.db = cached.client;
+            }
+            console.log('[MySQL] Reusing existing pool after database creation');
+            return;
+        }
+
         console.log('[MySQL] Retrying connection after database creation...');
         const client = new MySQLAsyncClient(config);
         await client.connect();
@@ -92,6 +118,11 @@ class schema{
         this.context._SQLEngine.setDB(pool);
         this.context._SQLEngine.__name = 'mysql2';
         this.context.db = client;
+
+        // Register in global pool cache so other contexts can reuse
+        if (_pools && key) {
+            _pools.set(key, { client, engine: this.context._SQLEngine, refCount: 1, dbType: 'mysql' });
+        }
         console.log('[MySQL] Connection pool ready');
     }
 
@@ -140,12 +171,40 @@ class schema{
         const config = this.context._dbConfig;
         if(!config){ throw new Error('No PostgreSQL config available for retry'); }
         const PostgresClient = require('masterrecord/postgresSyncConnect');
+
+        // Check global pool cache first -- another context may have already retried
+        const _pools = global.__MR_POOLS__;
+        const key = _pools ? this._poolKey('postgres', config) : null;
+
+        if (_pools && key && _pools.has(key)) {
+            const cached = _pools.get(key);
+            cached.refCount++;
+            if (cached.promise) {
+                const result = await cached.promise;
+                this.context._SQLEngine = result.engine;
+                this.context._SQLEngine.__name = 'pg';
+                this.context.db = result.pool;
+            } else {
+                this.context._SQLEngine = cached.engine;
+                this.context._SQLEngine.__name = 'pg';
+                this.context.db = cached.pool;
+            }
+            console.log('[PostgreSQL] Reusing existing pool after database creation');
+            return;
+        }
+
         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();
+        const pool = connection.getPool();
+        this.context.db = pool;
+
+        // Register in global pool cache so other contexts can reuse
+        if (_pools && key) {
+            _pools.set(key, { pool, engine: this.context._SQLEngine, client: connection, refCount: 1, dbType: 'postgres' });
+        }
         console.log('[PostgreSQL] Connection pool ready');
     }
 

package/context.js

@@ -376,6 +376,15 @@ class context {
             if (_pools.has(key)) {
                 const cached = _pools.get(key);
                 cached.refCount++;
+                if (cached.promise) {
+                    // Another caller is initializing -- await the same promise
+                    const result = await cached.promise;
+                    this._SQLEngine = result.engine;
+                    this.isMySQL = true;
+                    console.log(`[MySQL] Reusing pool for ${env.database} (refs: ${cached.refCount})`);
+                    return result.client;
+                }
+                // Already resolved
                 this._SQLEngine = cached.engine;
                 this.isMySQL = true;
                 console.log(`[MySQL] Reusing pool for ${env.database} (refs: ${cached.refCount})`);
@@ -383,18 +392,38 @@ class context {
             }
 
             console.log('[MySQL] Initializing async connection pool...');
-            const client = new MySQLAsyncClient(env);
-            await client.connect();
 
-            const pool = client.getPool();
-            this._SQLEngine = new MySQLEngine();
-            this._SQLEngine.setDB(pool);
-            this._SQLEngine.__name = sqlName;
-            this.isMySQL = true;
+            // Store promise IMMEDIATELY to prevent race condition with concurrent callers
+            const initPromise = (async () => {
+                const client = new MySQLAsyncClient(env);
+                await client.connect();
+                const pool = client.getPool();
+                const engine = new MySQLEngine();
+                engine.setDB(pool);
+                engine.__name = sqlName;
+                return { client, engine };
+            })();
+
+            _pools.set(key, { promise: initPromise, refCount: 1, dbType: 'mysql' });
 
-            _pools.set(key, { client, engine: this._SQLEngine, refCount: 1, dbType: 'mysql' });
+            let result;
+            try {
+                result = await initPromise;
+            } catch (err) {
+                // Remove failed entry so future callers can retry
+                _pools.delete(key);
+                throw err;
+            }
+
+            // Replace pending entry with resolved entry, preserving refCount from concurrent joiners
+            const pending = _pools.get(key);
+            const currentRefCount = pending ? pending.refCount : 1;
+            _pools.set(key, { client: result.client, engine: result.engine, refCount: currentRefCount, dbType: 'mysql' });
+
+            this._SQLEngine = result.engine;
+            this.isMySQL = true;
             console.log('[MySQL] Connection pool ready');
-            return client;
+            return result.client;
         } catch (error) {
             // Preserve original error if it's already a ContextError
             if (error instanceof ContextError) {
@@ -459,20 +488,49 @@ class context {
             if (_pools.has(key)) {
                 const cached = _pools.get(key);
                 cached.refCount++;
+                if (cached.promise) {
+                    // Another caller is initializing -- await the same promise
+                    const result = await cached.promise;
+                    this._SQLEngine = result.engine;
+                    this._SQLEngine.__name = sqlName;
+                    console.log(`[PostgreSQL] Reusing pool for ${env.database} (refs: ${cached.refCount})`);
+                    return result.pool;
+                }
+                // Already resolved
                 this._SQLEngine = cached.engine;
                 this._SQLEngine.__name = sqlName;
                 console.log(`[PostgreSQL] Reusing pool for ${env.database} (refs: ${cached.refCount})`);
                 return cached.pool;
             }
 
-            const connection = new PostgresClient();
-            await connection.connect(env);
-            this._SQLEngine = connection.getEngine();
-            this._SQLEngine.__name = sqlName;
+            // Store promise IMMEDIATELY to prevent race condition with concurrent callers
+            const initPromise = (async () => {
+                const connection = new PostgresClient();
+                await connection.connect(env);
+                const engine = connection.getEngine();
+                engine.__name = sqlName;
+                const pool = connection.getPool();
+                return { pool, engine, client: connection };
+            })();
+
+            _pools.set(key, { promise: initPromise, refCount: 1, dbType: 'postgres' });
 
-            const pool = connection.getPool();
-            _pools.set(key, { pool, engine: this._SQLEngine, client: connection, refCount: 1, dbType: 'postgres' });
-            return pool;
+            let result;
+            try {
+                result = await initPromise;
+            } catch (err) {
+                // Remove failed entry so future callers can retry
+                _pools.delete(key);
+                throw err;
+            }
+
+            // Replace pending entry with resolved entry, preserving refCount from concurrent joiners
+            const pending = _pools.get(key);
+            const currentRefCount = pending ? pending.refCount : 1;
+            _pools.set(key, { pool: result.pool, engine: result.engine, client: result.client, refCount: currentRefCount, dbType: 'postgres' });
+
+            this._SQLEngine = result.engine;
+            return result.pool;
         } catch (error) {
             // Preserve original error if it's already a ContextError
             if (error instanceof ContextError) {
@@ -2058,6 +2116,8 @@ class context {
     async close() {
         // Find this instance's pool in the registry and decrement
         for (const [key, entry] of _pools) {
+            // Skip pending entries -- they have no engine yet
+            if (entry.promise) continue;
             if (entry.engine === this._SQLEngine) {
                 entry.refCount--;
                 if (entry.refCount <= 0) {
@@ -2096,7 +2156,17 @@ class context {
     static async closeAll() {
         for (const [key, entry] of _pools) {
             try {
-                if (entry.engine && typeof entry.engine.close === 'function') {
+                if (entry.promise) {
+                    // Wait for pending init to complete, then close it
+                    try {
+                        const result = await entry.promise;
+                        if (result.engine && typeof result.engine.close === 'function') {
+                            await result.engine.close();
+                        }
+                    } catch (_initErr) {
+                        // Init failed -- nothing to close
+                    }
+                } else if (entry.engine && typeof entry.engine.close === 'function') {
                     await entry.engine.close();
                 }
             } catch (err) {
@@ -2118,7 +2188,8 @@ class context {
      */
     static getPoolStats() {
         return Array.from(_pools.entries()).map(([key, entry]) => ({
-            key, dbType: entry.dbType, refCount: entry.refCount
+            key, dbType: entry.dbType, refCount: entry.refCount,
+            status: entry.promise ? 'pending' : 'ready'
         }));
     }
 

package/deleteManager.js

@@ -77,19 +77,26 @@ class DeleteManager {
 
             // Check if this is a relationship that needs cascade deletion
             if (this._isRelationshipType(propertyConfig.type)) {
-                const relatedModel = entity[property];
+                // Read the backing field directly to avoid triggering lazy-loading
+                // getters, which can return Promises or error strings
+                const relatedModel = entity.__proto__
+                    ? entity.__proto__["_" + property]
+                    : entity["_" + property];
 
                 if (relatedModel === null || relatedModel === undefined) {
-                    // Check if relationship is required (not nullable)
-                    if (!propertyConfig.nullable) {
-                        throw new Error(
-                            `Cannot delete ${entity.__entity.__name}: ` +
-                            `required relationship '${property}' is null. ` +
-                            `Set nullable: true if this is intentional.`
-                        );
+                    // Unloaded relationships are safe to skip — the database
+                    // handles FK constraints; only cascade explicitly loaded data
+                    continue;
+                }
+
+                // Only cascade into values that are actual tracked entities
+                if (Array.isArray(relatedModel)) {
+                    for (const item of relatedModel) {
+                        if (item && item.__entity) {
+                            await this.cascadeDelete(item);
+                        }
                     }
-                } else {
-                    // Recursively delete related entities
+                } else if (relatedModel && relatedModel.__entity) {
                     await this.cascadeDelete(relatedModel);
                 }
             }
@@ -129,9 +136,23 @@ class DeleteManager {
                 const propertyConfig = entity.__entity[property];
 
                 if (this._isRelationshipType(propertyConfig.type)) {
-                    const relatedModel = entity[property];
+                    // Read backing field directly to avoid triggering lazy-loading getters
+                    const relatedModel = entity.__proto__
+                        ? entity.__proto__["_" + property]
+                        : entity["_" + property];
+
+                    if (relatedModel === null || relatedModel === undefined) {
+                        continue;
+                    }
 
-                    if (relatedModel !== null && relatedModel !== undefined) {
+                    // Only cascade into actual tracked entities
+                    if (Array.isArray(relatedModel)) {
+                        for (const item of relatedModel) {
+                            if (item && item.__entity) {
+                                await this.cascadeDelete(item);
+                            }
+                        }
+                    } else if (relatedModel && relatedModel.__entity) {
                         await this.cascadeDelete(relatedModel);
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "masterrecord",
-  "version": "0.3.64",
+  "version": "0.3.66",
   "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": {