@cocreate/lazy-loader 1.19.2 → 1.19.4

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.19.4](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.19.3...v1.19.4) (2024-05-10)
+
+
+### Bug Fixes
+
+* removed environment handling variables as it is database specific ([d63921c](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/d63921cb039c284ab452bf47f0802fc56a66eeb3))
+
+## [1.19.3](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.19.2...v1.19.3) (2024-05-08)
+
+
+### Bug Fixes
+
+* processOperators and processOperator functions ([984f19c](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/984f19cdad55bfb74b9599f910950ef91f174f00))
+
 ## [1.19.2](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.19.1...v1.19.2) (2024-04-29)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/lazy-loader",
-  "version": "1.19.2",
+  "version": "1.19.4",
   "description": "A simple lazy-loader component in vanilla javascript. Easily configured using HTML5 data-attributes and/or JavaScript API.",
   "keywords": [
     "lazy-loader",

package/src/server.js

@@ -156,14 +156,8 @@ class CoCreateLazyLoader {
             const name = methodPath.shift()
 
             const apis = await this.getApiKey(data, name)
-            let environment = 'production';
 
-            if (data.environment)
-                environment = data.environment
-            else if (data.host.startsWith('dev.') || data.host.startsWith('test.'))
-                environment = 'test'
-
-            const key = apis[environment].key;
+            const key = apis.key;
             if (!key)
                 throw new Error(`Missing ${name} key in organization apis object`);
 
@@ -205,29 +199,25 @@ class CoCreateLazyLoader {
     async webhooks(config, data, name) {
         try {
             const apis = await this.getApiKey(data, name)
-            if (data.environment)
-                environment = data.environment
-            else if (data.host.startsWith('dev.') || data.host.startsWith('test.'))
-                environment = 'test'
 
-            const key = apis[environment].key;
+            const key = apis.key;
             if (!key)
                 throw new Error(`Missing ${name} key in organization apis object`);
 
             let webhookName = data.req.url.split('/');
             webhookName = webhookName[webhookName.length - 1]
 
-            const webhook = apis[environment].webhooks[webhookName];
+            const webhook = apis.webhooks[webhookName];
             if (!webhook)
                 throw new Error(`Webhook ${name} ${webhookName} is not defined`);
 
             // eventDataKey is used to access the event data
-            let eventDataKey = webhook.eventDataKey || apis[environment].eventDataKey
+            let eventDataKey = webhook.eventDataKey || apis.eventDataKey
             if (!eventDataKey)
                 throw new Error(`Webhook ${name} eventKey is not defined`);
 
             // eventNameKey is used to access the event the event name
-            let eventNameKey = webhook.eventNameKey || apis[environment].eventNameKey
+            let eventNameKey = webhook.eventNameKey || apis.eventNameKey
             if (!eventNameKey)
                 throw new Error(`Webhook ${name} eventNameKey is not defined`);
 
@@ -252,15 +242,15 @@ class CoCreateLazyLoader {
 
             if (webhook.authenticate && webhook.authenticate.method) {
                 method = webhook.authenticate.method
-            } else if (apis[environment].authenticate && apis[environment].authenticate.method) {
-                method = apis[environment].authenticate.method
+            } else if (apis.authenticate && apis.authenticate.method) {
+                method = apis.authenticate.method
             } else
                 throw new Error(`Webhook ${name} authenticate method is not defined`);
 
             if (webhook.authenticate && webhook.authenticate.parameters) {
                 parameters = webhook.authenticate.parameters
-            } else if (apis[environment].authenticate && apis[environment].authenticate.parameters) {
-                parameters = apis[environment].authenticate.parameters
+            } else if (apis.authenticate && apis.authenticate.parameters) {
+                parameters = apis.authenticate.parameters
             } else
                 throw new Error(`Webhook ${name} authenticate parameters is not defined`);
 
@@ -311,32 +301,34 @@ class CoCreateLazyLoader {
         }
     }
 
-    async processOperators(data, event, execute, parent = null, parentKey = null) {
+    async processOperators(data, event, execute) {
         if (Array.isArray(execute)) {
             for (let index = 0; index < execute.length; index++) {
-                execute[index] = await this.processOperators(data, event, execute[index], execute, index);
+                execute[index] = await this.processOperators(data, event, execute[index]);
             }
         } else if (typeof execute === 'object' && execute !== null) {
             for (let key of Object.keys(execute)) {
-                if (key.startsWith('$')) {
-                    const operatorResult = await this.processOperator(data, event, key, execute[key]);
-                    if (parent && operatorResult !== null && parentKey !== null) {
-                        parent[parentKey] = operatorResult;
-                        await this.processOperators(data, event, parent[parentKey], parent, parentKey);
-                    }
-                } else {
-                    execute[key] = await this.processOperators(data, event, execute[key], execute, key);
+                if (key.startsWith('$') && !['$storage', '$database', '$array', '$filter'].includes(key)) {
+                    execute[key] = await this.processOperator(data, event, key, execute[key]);
+                } else if (typeof execute[key] === 'string' && execute[key].startsWith('$') && !['$storage', '$database', '$array', '$filter'].includes(execute[key])) {
+                    execute[key] = await this.processOperator(data, event, execute[key]);
+                } else if (Array.isArray(execute[key])) {
+                    execute[key] = await this.processOperators(data, event, execute[key]);
+                } else if (typeof execute[key] === 'object' && execute[key] !== null) {
+                    execute[key] = await this.processOperators(data, event, execute[key]);
                 }
             }
-        } else {
-            return await this.processOperator(data, event, execute);
+        } else if (typeof execute === 'string' && execute.startsWith('$') && !['$storage', '$database', '$array', '$filter'].includes(execute)) {
+            execute = await this.processOperator(data, event, execute);
         }
+
         return execute;
     }
 
     async processOperator(data, event, operator, context) {
         let result
         if (operator.startsWith('$data.')) {
+            result = getValueFromObject(data, operator.substring(6))
             return getValueFromObject(data, operator.substring(6))
         } else if (operator.startsWith('$req')) {
             return getValueFromObject(data, operator.substring(1))
@@ -385,36 +377,6 @@ class CoCreateLazyLoader {
 
 }
 
-
-// async function processOperators(data, event, execute, parent = null, parentKey = null) {
-//     if (Array.isArray(execute)) {
-//         execute.forEach(async (item, index) => await processOperators(data, event, item, execute, index));
-//     } else if (typeof execute === 'object' && execute !== null) {
-//         for (let key of Object.keys(execute)) {
-//             // Check if key is an operator
-//             if (key.startsWith('$')) {
-//                 const operatorResult = await processOperator(data, event, key, execute[key]);
-//                 if (parent && operatorResult !== null) {
-//                     if (parentKey !== null) {
-//                         parent[parentKey] = operatorResult;
-//                         await processOperators(data, event, parent[parentKey], parent, parentKey);
-//                     }
-//                     // else {
-//                     //     // Scenario 2: Replace the key (more complex, might require re-structuring the executable object)
-//                     //     delete parent[key]; // Remove the original key
-//                     //     parent[operatorResult] = execute[key]; // Assign the value to the new key
-//                     //     // Continue processing the new key if necessary
-//                     // }
-//                 }
-//             } else {
-//                 await processOperators(data, event, execute[key], execute, key);
-//             }
-//         }
-//     } else {
-//         return await processOperator(data, event, execute);
-//     }
-// }
-
 async function executeMethod(method, methodPath, instance, params) {
     try {
         switch (methodPath.length) {