masterrecord 0.3.16 → 0.3.18

package/deleteManager.js

@@ -26,14 +26,14 @@ class DeleteManager {
      * @param {Object|Array} currentModel - Entity or entities to delete
      * @throws {Error} If deletion fails
      */
-    init(currentModel) {
+    async init(currentModel) {
         // Input validation
         if (!currentModel) {
             throw new Error('DeleteManager.init() requires a valid model');
         }
 
         try {
-            this.cascadeDelete(currentModel);
+            await this.cascadeDelete(currentModel);
         } catch (error) {
             // Add context to error
             const entityName = currentModel.__entity?.__name || 'unknown';
@@ -46,15 +46,15 @@ class DeleteManager {
      * @param {Object|Array} currentModel - Entity or entities to delete
      * @throws {Error} If cascade deletion fails
      */
-    cascadeDelete(currentModel) {
+    async cascadeDelete(currentModel) {
         if (!currentModel) {
             return; // Nothing to delete
         }
 
         if (!Array.isArray(currentModel)) {
-            this._deleteSingleEntity(currentModel);
+            await this._deleteSingleEntity(currentModel);
         } else {
-            this._deleteMultipleEntities(currentModel);
+            await this._deleteMultipleEntities(currentModel);
         }
     }
 
@@ -63,7 +63,7 @@ class DeleteManager {
      * @private
      * @param {Object} entity - Entity to delete
      */
-    _deleteSingleEntity(entity) {
+    async _deleteSingleEntity(entity) {
         // Validate entity structure
         if (!entity.__entity) {
             throw new Error('Entity missing __entity metadata');
@@ -90,13 +90,13 @@ class DeleteManager {
                     }
                 } else {
                     // Recursively delete related entities
-                    this.cascadeDelete(relatedModel);
+                    await this.cascadeDelete(relatedModel);
                 }
             }
         }
 
         // Delete the entity itself after cascading
-        this._SQLEngine.delete(entity);
+        await this._SQLEngine.delete(entity);
     }
 
     /**
@@ -104,7 +104,7 @@ class DeleteManager {
      * @private
      * @param {Array} entities - Array of entities to delete
      */
-    _deleteMultipleEntities(entities) {
+    async _deleteMultipleEntities(entities) {
         if (entities.length === 0) {
             return; // Nothing to delete
         }
@@ -132,13 +132,13 @@ class DeleteManager {
                     const relatedModel = entity[property];
 
                     if (relatedModel !== null && relatedModel !== undefined) {
-                        this.cascadeDelete(relatedModel);
+                        await this.cascadeDelete(relatedModel);
                     }
                 }
             }
 
             // Delete the entity
-            this._SQLEngine.delete(entity);
+            await this._SQLEngine.delete(entity);
         }
     }
 

package/insertManager.js

@@ -71,8 +71,8 @@ class InsertManager {
      * @param {object} currentModel - Tracked entity to insert
      * @throws {InsertManagerError} If validation fails
      */
-    init(currentModel) {
-        this.runQueries(currentModel);
+    async init(currentModel) {
+        await this.runQueries(currentModel);
     }
 
     /**
@@ -81,7 +81,7 @@ class InsertManager {
      * @param {object} currentModel - Tracked entity to insert
      * @throws {InsertManagerError} If validation fails or relationships are invalid
      */
-    runQueries(currentModel) {
+    async runQueries(currentModel) {
         // Reset validation state for this operation to avoid stale errors
         if (this._errorModel) {
             this._errorModel.isValid = true;
@@ -94,8 +94,8 @@ class InsertManager {
         if (this._errorModel.isValid) {
             const modelEntity = currentModel.__entity;
             // TODO: if you try to add belongs to you must have a tag added first. if you dont throw error
-            currentModel = this.belongsToInsert(currentModel, modelEntity);
-            const SQL = this._SQLEngine.insert(cleanCurrentModel);
+            currentModel = await this.belongsToInsert(currentModel, modelEntity);
+            const SQL = await this._SQLEngine.insert(cleanCurrentModel);
             const primaryKey = tools.getPrimaryKeyObject(currentModel.__entity);
 
             // use returned insert id directly; avoid redundant post-insert SELECT
@@ -302,7 +302,7 @@ class InsertManager {
      * @param {object} modelEntity - Entity definition
      * @returns {object} Updated model with foreign keys populated
      */
-    belongsToInsert(currentModel, modelEntity) {
+    async belongsToInsert(currentModel, modelEntity) {
         for (const entity of Object.keys(modelEntity)) {
             if (modelEntity[entity].relationshipType === RELATIONSHIP_TYPES.BELONGS_TO) {
                 const foreignKey = modelEntity[entity].foreignKey === undefined
@@ -315,7 +315,7 @@ class InsertManager {
                     newPropertyModel.__entity = tools.getEntity(entity, this._allEntities);
                     const propertyCleanCurrentModel = tools.clearAllProto(newPropertyModel);
                     this.validateEntity(propertyCleanCurrentModel, newPropertyModel, newPropertyModel.__entity);
-                    const propertySQL = this._SQLEngine.insert(newPropertyModel);
+                    const propertySQL = await this._SQLEngine.insert(newPropertyModel);
                     currentModel[foreignKey] = propertySQL.id;
                 }
             }

package/mySQLAsyncConnect.js

@@ -0,0 +1,44 @@
+// Version 1.0.0 - MySQL async connection manager using mysql2/promise
+const mysql = require('mysql2/promise');
+
+class MySQLAsyncClient {
+    constructor(config) {
+        this.config = {
+            host: config.host || 'localhost',
+            port: config.port || 3306,
+            user: config.user,
+            password: config.password,
+            database: config.database,
+            waitForConnections: true,
+            connectionLimit: config.connectionLimit || 10,
+            queueLimit: 0
+        };
+        this.pool = null;
+    }
+
+    async connect() {
+        try {
+            this.pool = await mysql.createPool(this.config);
+            // Test connection
+            const connection = await this.pool.getConnection();
+            console.log('[MySQL] Connection pool initialized successfully');
+            connection.release();
+        } catch (error) {
+            console.error('[MySQL] Connection failed:', error.message);
+            throw error;
+        }
+    }
+
+    getPool() {
+        return this.pool;
+    }
+
+    async close() {
+        if (this.pool) {
+            await this.pool.end();
+            console.log('[MySQL] Connection pool closed');
+        }
+    }
+}
+
+module.exports = MySQLAsyncClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "masterrecord",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "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": {
@@ -31,7 +31,7 @@
     "glob": "^13.0.0",
     "deep-object-diff": "^1.1.9",
     "pg": "^8.17.2",
-    "sync-mysql2": "^1.0.8",
+    "mysql2": "^3.11.5",
     "app-root-path": "^3.1.0",
     "better-sqlite3": "^12.6.2"
   }