@cocreate/lazy-loader 1.17.0 → 1.19.0

package/CHANGELOG.md

@@ -1,3 +1,31 @@
+# [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)
+
+
+### Bug Fixes
+
+* handlng wbhook returned as string or object ([daf7438](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/daf7438bf8d6f049629112d056d9a598499cc23e))
+* imporved authentication handling ([dfc9b1c](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/dfc9b1c8b9fe547ff16d441e4b31b3f0332bacb8))
+* typo executeect updated to object ([a1b6258](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/a1b6258a7a88cd4e9847257fb552852342d9c7e3))
+
+
+### Features
+
+* authentication can be defined at envirnonemt level ([e4bf74c](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/e4bf74cdd8146bd390aec734d29e4177c3b264a7))
+* executeMethod() to handle dotNotion method without losing context ([8ab4f84](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/8ab4f8484073891dba4c154938ae597c21962c5f))
+* processOperators() to execute/rturn operator value ([e948ca2](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/e948ca24c1fb1ba5ae9718aaa466f0e26af78c74))
+
 # [1.17.0](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.16.0...v1.17.0) (2024-02-05)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/lazy-loader",
-  "version": "1.17.0",
+  "version": "1.19.0",
   "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
@@ -76,7 +79,7 @@ class CoCreateLazyLoader {
 
     async executeScriptWithTimeout(name, data) {
         try {
-            if (this.modules[name].initialize) {
+            if (this.modules[name].initialize || this.modules[name].initialize === '') {
                 if (data.req)
                     data = await this.webhooks(this.modules[name], data, name)
                 else
@@ -159,18 +162,11 @@ class CoCreateLazyLoader {
                 throw new Error(`Missing ${name} key in organization apis object`);
 
             const service = require(config.path);
-            const instance = new service[config.initialize](key);
-
-            let method = instance
-            for (let i = 0; i < methodPath.length; i++) {
-                method = method[methodPath[i]]
-                if (method === undefined) {
-                    throw new Error(`Method ${methodPath[i]} not found using ${data.method}.`);
-                }
-            }
-
-            if (typeof method !== 'function')
-                throw new Error(`Method ${data.method} is not a function.`);
+            let instance
+            if (config.initialize)
+                instance = new service[config.initialize](key);
+            else
+                instance = new service(key);
 
             let params = [], mainParam = false
             for (let i = 0; true; i++) {
@@ -185,7 +181,14 @@ class CoCreateLazyLoader {
                 }
             }
 
-            data.postmark = await method.apply(instance, params);
+            // TODO: should run processOperators before in order to perform complex opertions and get data
+            // data[name] = await processOperators(data, null, data[name]);
+
+            data[name] = await executeMethod(data.method, methodPath, instance, params)
+
+            // TODO: should run processOperators after in order to perform complex opertions and get data
+            // data[name] = await processOperators(data, data[name]);
+
             return data
         } catch (error) {
             data.error = error.message
@@ -204,18 +207,30 @@ class CoCreateLazyLoader {
             if (!key)
                 throw new Error(`Missing ${name} key in organization apis object`);
 
-            let name = data.req.url.split('/');
-            name = name[3] || name[2] || name[1]
+            let webhookName = data.req.url.split('/');
+            webhookName = webhookName[webhookName.length - 1]
 
-            // TODO: webhook secert could be a key pair
-            const webhookSecret = data.apis[environment].webhooks[name];
-            if (webhookSecret !== req.headers[name])
-                throw new Error(`Webhook secret failed for ${name}. Unauthorized access attempt.`);
+            const webhook = apis[environment].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
+            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
+            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();
@@ -225,13 +240,58 @@ class CoCreateLazyLoader {
                 });
             });
 
-            // TODO: if decrypt and validation is builtin to service   
-            // const service = require(config.path);
-            // const instance = new service[config.initialize](key);
+            let parameters, method
+
+
+            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
+                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
+                throw new Error(`Webhook ${name} authenticate parameters is not defined`);
+
+            // TODO: webhook secert could be a key pair
+
+            let event
+            if (!method) {
+                if (!parameters[0] !== parameters[1])
+                    throw new Error(`Webhook secret failed for ${name}. Unauthorized access attempt.`);
+
+                event = JSON.parse(data.rawBody)
+            } else {
+                const service = require(config.path);
+                let instance
+                if (config.initialize)
+                    instance = new service[config.initialize](key);
+                else
+                    instance = new service(key);
+
+                const methodPath = method.split('.')
+
+                await this.processOperators(data, '', parameters);
+
+                event = await executeMethod(method, methodPath, instance, parameters)
+            }
+
+            let eventName = getValueFromObject(event, eventNameKey)
+            if (!eventName)
+                throw new Error(`Webhook ${name} eventNameKey: ${eventNameKey} could not be found in the event.`);
 
-            // TODO: event may need to be handle by a built in service function
-            const event = JSON.parse(rawBody)
-            // TODO: using request.method and event.type get object and send socket.onMessage for proccessing
+            let eventData = getValueFromObject(event, eventDataKey)
+            if (!eventData)
+                throw new Error(`Webhook ${name} eventDataKey: ${eventDataKey} could not be found in the event.`);
+
+            let execute = webhook.events[eventName];
+            if (execute) {
+                execute = await this.processOperators(data, event, execute);
+            }
 
             data.res.writeHead(200, { 'Content-Type': 'application/json' });
             data.res.end(JSON.stringify({ message: 'Webhook received and processed' }));
@@ -244,6 +304,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)
@@ -257,6 +378,75 @@ 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) {
+            case 1:
+                return await instance[methodPath[0]](...params)
+            case 2:
+                return await instance[methodPath[0]][methodPath[1]](...params);
+            case 3:
+                return await instance[methodPath[0]][methodPath[1]][methodPath[2]](...params);
+            case 4:
+                return await instance[methodPath[0]][methodPath[1]][methodPath[2]][methodPath[3]](...params);
+            case 5:
+                return await instance[methodPath[0]][methodPath[1]][methodPath[2]][methodPath[3]][methodPath[4]](...params);
+            case 6:
+                return await instance[methodPath[0]][methodPath[1]][methodPath[2]][methodPath[3]][methodPath[4]][methodPath[5]](...params);
+            case 7:
+                return await instance[methodPath[0]][methodPath[1]][methodPath[2]][methodPath[3]][methodPath[4]][methodPath[5]][methodPath[6]](...params);
+            case 8:
+                return await instance[methodPath[0]][methodPath[1]][methodPath[2]][methodPath[3]][methodPath[4]][methodPath[5]][methodPath[6]][methodPath[7]](...params);
+            default:
+                const methodName = methodPath.pop();
+                let Method = instance
+                for (let i = 0; i < methodPath.length; i++) {
+                    Method = Method[methodPath[i]]
+                    if (Method === undefined) {
+                        throw new Error(`Method ${methodPath[i]} not found using ${method}.`);
+                    }
+                }
+
+                if (typeof Method[methodName] !== 'function')
+                    throw new Error(`Method ${method} is not a function.`);
+
+                return await Method[methodName](...params)
+        }
+    } catch (error) {
+        throw new Error(`Method ${method} not found.`);
+    }
+}
+
 function getModuleDependencies(modulePath) {
     let moduleObj = require.cache[modulePath];
     if (!moduleObj) {
@@ -343,4 +533,7 @@ async function fetchScriptFromDatabaseAndSave(name, moduleConfig) {
     return src;
 }
 
+
+
+
 module.exports = CoCreateLazyLoader;