masterrecord 0.3.21 → 0.3.23

package/QueryLanguage/queryMethods.js

@@ -164,7 +164,7 @@ class queryMethods{
     // ------------------------------- FUNCTIONS THAT MAKE THE SQL CALL START FROM HERE ON -----------------------------------------------------
     // ---------------------------------------------------------------------------------------------------------------------------------------
 
-    count(query,  ...args){
+    async count(query,  ...args){
         if(query){
             var str = query.toString();
             str = this.__validateAndCollectParameters(str, args, 'count');
@@ -173,7 +173,7 @@ class queryMethods{
 
         if(this.__context.isSQLite){
             // trying to match string select and relace with select Count(*);
-            var entityValue = this.__context._SQLEngine.getCount(this.__queryObject, this.__entity, this.__context);
+            var entityValue = await this.__context._SQLEngine.getCount(this.__queryObject, this.__entity, this.__context);
             var val = entityValue[Object.keys(entityValue)[0]];
             this.__reset();
             return val;
@@ -181,7 +181,7 @@ class queryMethods{
 
         if(this.__context.isMySQL){
             // trying to match string select and relace with select Count(*);
-            var entityValue = this.__context._SQLEngine.getCount(this.__queryObject, this.__entity, this.__context);
+            var entityValue = await this.__context._SQLEngine.getCount(this.__queryObject, this.__entity, this.__context);
             var val = entityValue[Object.keys(entityValue)[0]];
             this.__reset();
             return val;
@@ -309,7 +309,7 @@ class queryMethods{
     }
 
     // Convenience method: Find record by primary key ID
-    findById(id){
+    async findById(id){
         // Find the primary key field in the entity
         let primaryKeyField = null;
         for (const fieldName in this.__entity) {
@@ -329,10 +329,10 @@ class queryMethods{
         const whereClause = `${entityParam} => ${entityParam}.${primaryKeyField} == $$`;
 
         // Chain where() and single()
-        return this.where(whereClause, id).single();
+        return await this.where(whereClause, id).single();
     }
 
-    single(){
+    async single(){
         // If no clauses were used before single(), seed defaults so SQL is valid
         if(this.__queryObject.script.entityMap.length === 0){
             this.__queryObject.skipClause(this.__entity.__name);
@@ -357,12 +357,12 @@ class queryMethods{
         // Cache miss - execute query
         var result = null;
         if(this.__context.isSQLite){
-            var entityValue = this.__context._SQLEngine.get(this.__queryObject.script, this.__entity, this.__context);
+            var entityValue = await this.__context._SQLEngine.get(this.__queryObject.script, this.__entity, this.__context);
             result = this.__singleEntityBuilder(entityValue);
         }
 
         if(this.__context.isMySQL){
-            var entityValue = this.__context._SQLEngine.get(this.__queryObject.script, this.__entity, this.__context);
+            var entityValue = await this.__context._SQLEngine.get(this.__queryObject.script, this.__entity, this.__context);
             result = this.__singleEntityBuilder(entityValue[0]);
         }
 
@@ -375,7 +375,7 @@ class queryMethods{
         return result;
     }
 
-    toList(){
+    async toList(){
         if(this.__queryObject.script.entityMap.length === 0){
             this.__queryObject.skipClause( this.__entity.__name);
             if(!this.__queryObject.script.take || this.__queryObject.script.take === 0){
@@ -401,12 +401,12 @@ class queryMethods{
         // Cache miss - execute query
         var result = [];
         if(this.__context.isSQLite){
-            var entityValue = this.__context._SQLEngine.all(this.__queryObject.script, this.__entity, this.__context);
+            var entityValue = await this.__context._SQLEngine.all(this.__queryObject.script, this.__entity, this.__context);
             result = this.__multipleEntityBuilder(entityValue);
         }
 
         if(this.__context.isMySQL){
-            var entityValue = this.__context._SQLEngine.all(this.__queryObject.script, this.__entity, this.__context);
+            var entityValue = await this.__context._SQLEngine.all(this.__queryObject.script, this.__entity, this.__context);
             result = this.__multipleEntityBuilder(entityValue);
         }
 

package/context.js

@@ -1478,7 +1478,7 @@ class context {
         }
 
         // Load entity
-        const entity = EntityClass.findById(primaryKey);
+        const entity = await EntityClass.findById(primaryKey);
         if (!entity) {
             throw new EntityValidationError(
                 `${entityName} with id ${primaryKey} not found`,

package/insertManager.js

@@ -115,15 +115,15 @@ class InsertManager {
                 const entityProperty = modelEntity[property] ? modelEntity[property] : {};
 
                 if (entityProperty.type === RELATIONSHIP_TYPES.HAS_ONE) {
-                    this._processHasOneRelationship(propertyModel, entityProperty, property, currentModel, SQL);
+                    await this._processHasOneRelationship(propertyModel, entityProperty, property, currentModel, SQL);
                 }
 
                 if (entityProperty.type === RELATIONSHIP_TYPES.HAS_MANY) {
-                    this._processArrayRelationship(propertyModel, entityProperty, property, currentModel, SQL, RELATIONSHIP_TYPES.HAS_MANY);
+                    await this._processArrayRelationship(propertyModel, entityProperty, property, currentModel, SQL, RELATIONSHIP_TYPES.HAS_MANY);
                 }
 
                 if (entityProperty.type === RELATIONSHIP_TYPES.HAS_MANY_THROUGH) {
-                    this._processArrayRelationship(propertyModel, entityProperty, property, currentModel, SQL, RELATIONSHIP_TYPES.HAS_MANY_THROUGH);
+                    await this._processArrayRelationship(propertyModel, entityProperty, property, currentModel, SQL, RELATIONSHIP_TYPES.HAS_MANY_THROUGH);
                 }
             }
         } else {
@@ -147,7 +147,7 @@ class InsertManager {
      * @param {object} SQL - SQL result from parent insert
      * @throws {RelationshipError} If relationship entity is not found
      */
-    _processHasOneRelationship(propertyModel, entityProperty, property, currentModel, SQL) {
+    async _processHasOneRelationship(propertyModel, entityProperty, property, currentModel, SQL) {
         // only insert child if user provided a concrete object with data
         if (propertyModel && typeof propertyModel === 'object') {
             // check if model has its own entity
@@ -169,7 +169,7 @@ class InsertManager {
 
             propertyModel.__entity = tools.getEntity(property, this._allEntities);
             propertyModel[currentModel.__entity.__name] = SQL.id;
-            this.runQueries(propertyModel);
+            await this.runQueries(propertyModel);
 
             // Hydrate child back as a tracked instance so subsequent property sets are tracked
             try {
@@ -187,7 +187,7 @@ class InsertManager {
 
                     const ctxSetName = tools.capitalizeFirstLetter(property);
                     if (currentModel.__context && currentModel.__context[ctxSetName]) {
-                        const trackedChild = currentModel.__context[ctxSetName]
+                        const trackedChild = await currentModel.__context[ctxSetName]
                             .where(`r => r.${childPk} == $$`, childId)
                             .single();
                         if (trackedChild) {
@@ -218,7 +218,7 @@ class InsertManager {
      * @param {string} relationshipType - 'hasMany' or 'hasManyThrough'
      * @throws {RelationshipError} If validation fails or entity not resolved
      */
-    _processArrayRelationship(propertyModel, entityProperty, property, currentModel, SQL, relationshipType) {
+    async _processArrayRelationship(propertyModel, entityProperty, property, currentModel, SQL, relationshipType) {
         // skip when not provided; only enforce array type if user supplied a value
         if (propertyModel === undefined || propertyModel === null) {
             return;
@@ -263,7 +263,7 @@ class InsertManager {
 
             propertyModel[propertykey].__entity = resolved;
             propertyModel[propertykey][currentModel.__entity.__name] = SQL.id;
-            this.runQueries(propertyModel[propertykey]);
+            await this.runQueries(propertyModel[propertykey]);
         }
     }
 

package/package.json

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