@cocreate/lazy-loader 1.17.0 → 1.18.0

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+# [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.18.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

@@ -76,7 +76,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 +159,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 +178,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,13 +204,23 @@ 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`);
+
+            let dataKey = webhook.dataKey || apis[environment].dataKey
+            if (!dataKey)
+                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`);
+
+            if (!webhook.events)
+                throw new Error(`Webhook ${name} events are not defined`);
 
             let rawBody = '';
             await new Promise((resolve, reject) => {
@@ -225,13 +235,52 @@ 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) {
+                method = webhook.authenticate.method
+                parameters = webhook.authenticate.parameters
+            }
+
+            if (!parameters && 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
+
+            // TODO: webhook secert could be a key pair
 
-            // 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 event
+            if (!method) {
+                if (!parameters[0] !== parameters[1])
+                    throw new Error(`Webhook secret failed for ${name}. Unauthorized access attempt.`);
+
+                event = JSON.parse(rawBody)
+            } else {
+                const service = require(config.path);
+                let instance
+                if (config.initialize)
+                    instance = new service[config.initialize](key);
+                else
+                    instance = new service(key);
+
+                event = await executeMethod(name + '.' + method, methodPath, instance, parameters)
+            }
+
+            let eventName = getValueFromObject(event, nameKey)
+            if (!eventName)
+                throw new Error(`Webhook ${name} nameKey: ${nameKey} could not be found in the event.`);
+
+            let eventData = getValueFromObject(event, dataKey)
+            if (!eventData)
+                throw new Error(`Webhook ${name} dataKey: ${dataKey} could not be found in the event.`);
+
+            let execute = webhook.events[eventName];
+            if (execute) {
+                execute = await processOperators(data, event, execute);
+            }
 
             data.res.writeHead(200, { 'Content-Type': 'application/json' });
             data.res.end(JSON.stringify({ message: 'Webhook received and processed' }));
@@ -257,6 +306,101 @@ 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 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 +487,7 @@ async function fetchScriptFromDatabaseAndSave(name, moduleConfig) {
     return src;
 }
 
+
+
+
 module.exports = CoCreateLazyLoader;