@cocreate/lazy-loader 1.15.2 → 1.16.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [1.16.0](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.15.2...v1.16.0) (2024-01-30)
+
+
+### Bug Fixes
+
+* error handling ([6bde772](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/6bde772156c95487a7c7abba494ee508c631fd99))
+* getOrganization accepts one param ([bd2336a](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/bd2336a32033cd631199995cf4e4878451524010))
+
+
+### Features
+
+* dynamically handles any third paty api and webhooks ([6ac3c2d](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/6ac3c2dce8786315ca9daaaa375e9ea480ecdf51))
+* operator $params to define an array of params and their data/values. ([31b6ec7](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/31b6ec728a7330410447229376a776d23011fc55))
+
 ## [1.15.2](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.15.1...v1.15.2) (2024-01-17)
 
 

package/package.json

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

@@ -4,8 +4,6 @@ const vm = require('vm');
 const Config = require("@cocreate/config");
 const { URL } = require('url');
 
-// const organizations = {};
-
 class CoCreateLazyLoader {
     constructor(server, crud, files) {
         this.server = server
@@ -48,10 +46,12 @@ class CoCreateLazyLoader {
         try {
             const valideUrl = new URL(`http://${req.headers.host}${req.url}`);
             const hostname = valideUrl.hostname;
-
-            let organization = await this.crud.getHost(hostname);
-            if (organization.error)
+            let organization
+            try {
+                organization = await this.crud.getOrganization({ host: hostname });
+            } catch {
                 return this.files.send(req, res, this.crud, organization, valideUrl)
+            }
 
             if (valideUrl.pathname.startsWith('/webhooks/')) {
                 let name = req.url.split('/')[2]; // Assuming URL structure is /webhook/name/...
@@ -75,30 +75,38 @@ class CoCreateLazyLoader {
 
     async executeScriptWithTimeout(name, data) {
         try {
-            if (!this.modules[name].content) {
-                if (this.modules[name].path)
-                    this.modules[name].content = await require(this.modules[name].path)
-                else {
-                    try {
-                        const scriptPath = path.join(scriptsDirectory, `${name}.js`);
-                        await fs.access(scriptPath);
-                        this.modules[name].content = await fs.readFile(scriptPath, 'utf8');
-                    } catch {
-                        this.modules[name].content = await fetchScriptFromDatabaseAndSave(name, this.modules[name], data);
+            if (this.modules[name].initialize) {
+                if (data.req)
+                    data = await this.webhooks(this.modules[name], data, name)
+                else
+                    data = await this.api(this.modules[name], data)
+            } else {
+                if (!this.modules[name].content) {
+                    if (this.modules[name].path)
+                        this.modules[name].content = await require(this.modules[name].path)
+                    else {
+                        try {
+                            const scriptPath = path.join(scriptsDirectory, `${name}.js`);
+                            await fs.access(scriptPath);
+                            this.modules[name].content = await fs.readFile(scriptPath, 'utf8');
+                        } catch {
+                            this.modules[name].content = await fetchScriptFromDatabaseAndSave(name, this.modules[name], data);
+                        }
                     }
                 }
+
+                if (this.modules[name].content) {
+                    data.apis = await this.getApiKey(data, name)
+                    data.crud = this.crud
+                    data = await this.modules[name].content.send(data)
+                    delete data.apis
+                    delete data.crud
+                } else
+                    return
             }
 
-            if (this.modules[name].content) {
-                data.apis = await this.getApiKey(data.organization_id, name)
-                data.crud = this.crud
-                data = await this.modules[name].content.send(data)
-                delete data.apis
-                delete data.crud
-                if (data.socket)
-                    this.wsManager.send(data)
-            } else
-                return
+            if (data.socket)
+                this.wsManager.send(data)
 
             if (this.modules[name].unload === false || this.modules[name].unload === 'false')
                 return
@@ -129,18 +137,108 @@ class CoCreateLazyLoader {
                 this.modules[name].timeout = timeout
             }
         } catch (error) {
-            console.log(error)
+            data.error = error.message
+            if (data.req) {
+                data.res.writeHead(400, { 'Content-Type': 'text/plain' });
+                data.res.end(`Lazyload Error: ${error.message}`);
+            } if (data.socket)
+                this.wsManager.send(data)
+        }
+    }
+
+    async api(config, data) {
+        try {
+            const methodPath = data.method.split('.')
+            const name = methodPath.shift()
+
+            const apis = await this.getApiKey(data, name)
+            const environment = data.environment || 'production';
+            const key = apis[environment].key;
+            if (!key)
+                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 params = data.$params || [data[name]]
+            data.postmark = await method.apply(instance, params);
+            return data
+        } catch (error) {
+            data.error = error.message
+            return data
+        }
+    }
+
+    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.'))
+                environment = 'test'
+
+            const key = apis[environment].key;
+            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]
+
+            // 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.`);
+
+            let rawBody = '';
+            await new Promise((resolve, reject) => {
+                data.req.on('data', chunk => {
+                    rawBody += chunk.toString();
+                });
+                data.req.on('end', () => {
+                    resolve();
+                });
+                data.req.on('error', (err) => {
+                    reject(err);
+                });
+            });
+
+            // TODO: if decrypt and validation is builtin to service   
+            // const service = require(config.path);
+            // const instance = new service[config.initialize](key);
+
+            // 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
+
+            data.res.writeHead(200, { 'Content-Type': 'application/json' });
+            data.res.end(JSON.stringify({ message: 'Webhook received and processed' }));
+            return data
+        } catch (error) {
+            data.error = error.message
+            data.res.writeHead(400, { 'Content-Type': 'text/plain' });
+            data.res.end(error.message);
+            return data
         }
     }
 
-    async getApiKey(organization_id, name) {
-        let organization = await this.crud.getOrganization(organization_id, false);
+    async getApiKey(data, name) {
+        let organization = await this.crud.getOrganization(data);
         if (organization.error)
-            return organization.error
+            throw new Error(organization.error);
         if (!organization.apis)
-            return { error: 'Missing apis object in organization object' }
+            throw new Error('Missing apis object in organization object');
         if (!organization.apis[name])
-            return { error: `Missing ${name} in organization apis object` }
+            throw new Error(`Missing ${name} in organization apis object`);
         return organization.apis[name]
     }