@cocreate/lazy-loader 1.18.0 → 1.19.1

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [1.19.1](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.19.0...v1.19.1) (2024-04-27)
+
+
+### Bug Fixes
+
+* eniroment declaration and error handling of execute method ([659d947](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/659d947af1226c77b4cbcbaaed10596ade73183f))
+
+# [1.19.0](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.18.0...v1.19.0) (2024-04-26)
+
+
+### Bug Fixes
+
+* added processOperators and processOperator to lazyLoader class ([973f07a](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/973f07ac492dee348f15b6889c15e180cf4d3eb0))
+
+
+### Features
+
+* dynamically handle webhooks using operations and objects to perform actions ([c1f17b4](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/c1f17b47304bd9c0b44ba591809dfee3c7186992))
+
 # [1.18.0](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.17.0...v1.18.0) (2024-03-18)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/lazy-loader",
-  "version": "1.18.0",
+  "version": "1.19.1",
   "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

@@ -1,8 +1,10 @@
 const fs = require('fs').promises;
 const path = require('path');
+const { URL } = require('url');
 const vm = require('vm');
 const Config = require("@cocreate/config");
-const { URL } = require('url');
+const { getValueFromObject } = require('@cocreate/utils');
+
 
 class CoCreateLazyLoader {
     constructor(server, crud, files) {
@@ -44,6 +46,7 @@ class CoCreateLazyLoader {
 
     async request(req, res) {
         try {
+            // TODO: track usage
             const valideUrl = new URL(`http://${req.headers.host}${req.url}`);
             const hostname = valideUrl.hostname;
             let organization
@@ -153,7 +156,13 @@ class CoCreateLazyLoader {
             const name = methodPath.shift()
 
             const apis = await this.getApiKey(data, name)
-            const environment = data.environment || 'production';
+            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;
             if (!key)
                 throw new Error(`Missing ${name} key in organization apis object`);
@@ -196,8 +205,9 @@ class CoCreateLazyLoader {
     async webhooks(config, data, name) {
         try {
             const apis = await this.getApiKey(data, name)
-            let environment = data.environment || 'production';
-            if (data.host.startsWith('dev.') || data.host.startsWith('test.'))
+            if (data.environment)
+                environment = data.environment
+            else if (data.host.startsWith('dev.') || data.host.startsWith('test.'))
                 environment = 'test'
 
             const key = apis[environment].key;
@@ -211,21 +221,23 @@ class CoCreateLazyLoader {
             if (!webhook)
                 throw new Error(`Webhook ${name} ${webhookName} is not defined`);
 
-            let dataKey = webhook.dataKey || apis[environment].dataKey
-            if (!dataKey)
+            // eventDataKey is used to access the event data
+            let eventDataKey = webhook.eventDataKey || apis[environment].eventDataKey
+            if (!eventDataKey)
                 throw new Error(`Webhook ${name} eventKey is not defined`);
 
-            let nameKey = webhook.nameKey || apis[environment].nameKey
-            if (!nameKey)
-                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
+            if (!eventNameKey)
+                throw new Error(`Webhook ${name} eventNameKey is not defined`);
 
             if (!webhook.events)
                 throw new Error(`Webhook ${name} events are not defined`);
 
-            let rawBody = '';
+            data.rawBody = '';
             await new Promise((resolve, reject) => {
                 data.req.on('data', chunk => {
-                    rawBody += chunk.toString();
+                    data.rawBody += chunk.toString();
                 });
                 data.req.on('end', () => {
                     resolve();
@@ -237,18 +249,20 @@ class CoCreateLazyLoader {
 
             let parameters, method
 
-            if (webhook.authenticate) {
+
+            if (webhook.authenticate && webhook.authenticate.method) {
                 method = webhook.authenticate.method
-                parameters = webhook.authenticate.parameters
-            }
+            } else if (apis[environment].authenticate && apis[environment].authenticate.method) {
+                method = apis[environment].authenticate.method
+            } else
+                throw new Error(`Webhook ${name} authenticate method is not defined`);
 
-            if (!parameters && apis[environment].authenticate && apis[environment].authenticate.parameters) {
+            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
-                throw new Error(`Webhook secret ${name} is not defined`);
-
-            if (!method && apis[environment].authenticate)
-                method = apis[environment].authenticate.method
+                throw new Error(`Webhook ${name} authenticate parameters is not defined`);
 
             // TODO: webhook secert could be a key pair
 
@@ -257,7 +271,7 @@ class CoCreateLazyLoader {
                 if (!parameters[0] !== parameters[1])
                     throw new Error(`Webhook secret failed for ${name}. Unauthorized access attempt.`);
 
-                event = JSON.parse(rawBody)
+                event = JSON.parse(data.rawBody)
             } else {
                 const service = require(config.path);
                 let instance
@@ -266,20 +280,24 @@ class CoCreateLazyLoader {
                 else
                     instance = new service(key);
 
-                event = await executeMethod(name + '.' + method, methodPath, instance, parameters)
+                const methodPath = method.split('.')
+
+                await this.processOperators(data, '', parameters);
+
+                event = await executeMethod(method, methodPath, instance, parameters)
             }
 
-            let eventName = getValueFromObject(event, nameKey)
+            let eventName = getValueFromObject(event, eventNameKey)
             if (!eventName)
-                throw new Error(`Webhook ${name} nameKey: ${nameKey} could not be found in the event.`);
+                throw new Error(`Webhook ${name} eventNameKey: ${eventNameKey} could not be found in the event.`);
 
-            let eventData = getValueFromObject(event, dataKey)
+            let eventData = getValueFromObject(event, eventDataKey)
             if (!eventData)
-                throw new Error(`Webhook ${name} dataKey: ${dataKey} could not be found in the event.`);
+                throw new Error(`Webhook ${name} eventDataKey: ${eventDataKey} could not be found in the event.`);
 
             let execute = webhook.events[eventName];
             if (execute) {
-                execute = await processOperators(data, event, execute);
+                execute = await this.processOperators(data, event, execute);
             }
 
             data.res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -293,6 +311,67 @@ class CoCreateLazyLoader {
         }
     }
 
+    async processOperators(data, event, execute, parent = null, parentKey = null) {
+        if (Array.isArray(execute)) {
+            for (let index = 0; index < execute.length; index++) {
+                execute[index] = await this.processOperators(data, event, execute[index], 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);
+                }
+            }
+        } else {
+            return await this.processOperator(data, event, execute);
+        }
+        return execute;
+    }
+
+    async processOperator(data, event, operator, context) {
+        let result
+        if (operator.startsWith('$data.')) {
+            return getValueFromObject(data, operator.substring(6))
+        } else if (operator.startsWith('$req')) {
+            return getValueFromObject(data, operator.substring(1))
+        } else if (operator.startsWith('$header')) {
+            return getValueFromObject(data.req, operator.substring(1))
+        } else if (operator.startsWith('$rawBody')) {
+            return getValueFromObject(data, operator.substring(1))
+        } else if (operator.startsWith('$crud')) {
+            context = await this.processOperators(data, event, context);
+            result = await this.crud.send(context)
+            if (operator.startsWith('$crud.'))
+                result = getValueFromObject(operator, operator.substring(6))
+            return await this.processOperators(data, event, result);
+        } else if (operator.startsWith('$socket')) {
+            context = await this.processOperators(data, event, context);
+            result = await this.socket.send(context)
+            if (operator.startsWith('$socket.'))
+                result = getValueFromObject(operator, operator.substring(6))
+            return await this.processOperators(data, event, result);
+        } else if (operator.startsWith('$api')) {
+            context = await this.processOperators(data, event, context);
+            let name = context.method.split('.')[0]
+            result = this.executeScriptWithTimeout(name, context)
+            if (operator.startsWith('$api.'))
+                result = getValueFromObject(event, operator.substring(5))
+            return await this.processOperators(data, event, result);
+        } else if (operator.startsWith('$event')) {
+            if (operator.startsWith('$event.'))
+                result = getValueFromObject(event, operator.substring(7))
+            return await this.processOperators(data, event, result);
+        }
+
+        return operator;
+    }
+
     async getApiKey(data, name) {
         let organization = await this.crud.getOrganization(data);
         if (organization.error)
@@ -306,61 +385,35 @@ 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 processOperator(data, event, operator, context) {
-    if (operator.startsWith('$data.')) {
-        operator = getValueFromObject(data, operator.substring(6))
-    } else if (operator.startsWith('$req.')) {
-        operator = getValueFromObject(data.req, operator.substring(5))
-    } else if (operator.startsWith('$header.')) {
-        operator = getValueFromObject(data.req.header, operator.substring(7))
-    } else if (operator.startsWith('$crud')) {
-        operator = await data.crud.send(context)
-        let name = operator.method.split('.')[0]
-        operator = operator[name]
-    } else if (operator.startsWith('$socket')) {
-        operator = await data.socket.send(context)
-        let name = operator.method.split('.')[0]
-        operator = operator[name]
-    } else if (operator.startsWith('$api')) {
-        let name = context.method.split('.')[0]
-        operator = this.executeScriptWithTimeout(name, context)
-    } else if (operator.startsWith('$webhook.')) {
-        operator = getValueFromObject(webhook, operator.substring(9))
-    } else if (operator.startsWith('$event.')) {
-        operator = getValueFromObject(event, operator.substring(7))
-    }
-
-    return operator;
-}
+// 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 {
@@ -397,7 +450,7 @@ async function executeMethod(method, methodPath, instance, params) {
                 return await Method[methodName](...params)
         }
     } catch (error) {
-        throw new Error(`Method ${method} not found.`);
+        throw new Error(error);
     }
 }