@cocreate/lazy-loader 1.9.0 → 1.11.0

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+# [1.11.0](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.10.0...v1.11.0) (2023-12-09)
+
+
+### Bug Fixes
+
+* add "@cocreate/config" ([bac22b5](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/bac22b5d4e5bafd83e68fe1ca727b184f07e8231))
+
+
+### Features
+
+* handle http and websocket requests ([07b205c](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/07b205c31527e10c55f716a6ea1db243bebcccfd))
+
+# [1.10.0](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.9.0...v1.10.0) (2023-12-01)
+
+
+### Features
+
+* get config using CoCreate-config ([8e0b9fc](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/8e0b9fce220c493a1db250cf424345d7708a2e08))
+* lazyload client and server modules ([80e25d6](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/80e25d67d729eaec18775a43bf1ef10cb9141aa8))
+
 # [1.9.0](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.8.0...v1.9.0) (2023-11-25)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/lazy-loader",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "A simple lazy-loader component in vanilla javascript. Easily configured using HTML5 data-attributes and/or JavaScript API.",
   "keywords": [
     "lazy-loader",
@@ -58,6 +58,7 @@
     "webpack-log": "^3.0.1"
   },
   "dependencies": {
+    "@cocreate/config": "^1.10.0",
     "@cocreate/observer": "^1.14.0"
   }
 }

package/src/client.js

@@ -0,0 +1,61 @@
+import observer from '@cocreate/observer';
+
+function listen(callback, selector) {
+
+    function observerCallback({ target }) {
+        // let isInit = target.querySelector(selector)/testtt
+        // if (isInit) {
+        callback()
+        // console.log('lazyloaded', selector)
+        observer.uninit(observerCallback)
+        // }
+    }
+
+    observer.init({
+        name: 'lazyloadObserver',
+        observe: ['childList'],
+        target: selector,
+        callback: observerCallback
+    })
+
+    let selectorAttributes = [];
+    let attributes = selector.split(",")
+    for (let attribute of attributes) {
+        let attr = attribute.trim()
+        if (attr.startsWith("[")) {
+            let pos = attr.indexOf("*")
+            if (pos == -1)
+                pos = attr.indexOf("=")
+            if (pos !== -1) {
+                attr = attr.slice(1, pos)
+            } else {
+                attr = attr.slice(1, -1)
+            }
+            selectorAttributes.push(attr)
+        }
+
+    }
+    if (selectorAttributes.length > 0)
+        observer.init({
+            name: 'lazyloadAttributeObserver',
+            observe: ['attributes'],
+            attributeName: selectorAttributes,
+            target: selector,
+            callback: observerCallback
+        });
+
+}
+
+export async function lazyLoad(name, selector, callback) {
+    if (document.querySelector(selector))
+        await dependency(name, await callback())
+    else
+        listen(callback, selector)
+}
+
+export async function dependency(name, promise) {
+    let component = await promise;
+    Object.assign(window.CoCreate, {
+        [name]: component.default
+    });
+}

package/src/index.js

@@ -1,61 +1,14 @@
-import observer from '@cocreate/observer';
-
-function listen(callback, selector) {
-
-    function observerCallback({ target }) {
-        // let isInit = target.querySelector(selector)
-        // if (isInit) {
-        callback()
-        // console.log('lazyloaded', selector)
-        observer.uninit(observerCallback)
-        // }
-    }
-
-    observer.init({
-        name: 'lazyloadObserver',
-        observe: ['childList'],
-        target: selector,
-        callback: observerCallback
-    })
-
-    let selectorAttributes = [];
-    let attributes = selector.split(",")
-    for (let attribute of attributes) {
-        let attr = attribute.trim()
-        if (attr.startsWith("[")) {
-            let pos = attr.indexOf("*")
-            if (pos == -1)
-                pos = attr.indexOf("=")
-            if (pos !== -1) {
-                attr = attr.slice(1, pos)
-            } else {
-                attr = attr.slice(1, -1)
-            }
-            selectorAttributes.push(attr)
-        }
-
-    }
-    if (selectorAttributes.length > 0)
-        observer.init({
-            name: 'lazyloadAttributeObserver',
-            observe: ['attributes'],
-            attributeName: selectorAttributes,
-            target: selector,
-            callback: observerCallback
+(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        define(["./client"], function (CoCreateLazyLoader) {
+            return factory(CoCreateLazyLoader)
         });
-
-}
-
-export async function lazyLoad(name, selector, callback) {
-    if (document.querySelector(selector))
-        await dependency(name, await callback())
-    else
-        listen(callback, selector)
-}
-
-export async function dependency(name, promise) {
-    let component = await promise;
-    Object.assign(window.CoCreate, {
-        [name]: component.default
-    });
-}
+    } else if (typeof module === 'object' && module.exports) {
+        const CoCreateLazyLoader = require("./server.js")
+        module.exports = factory(CoCreateLazyLoader);
+    } else {
+        root.returnExports = factory(root["./client.js"]);
+    }
+}(typeof self !== 'undefined' ? self : this, function (CoCreateLazyLoader) {
+    return CoCreateLazyLoader;
+}));

package/src/server.js

@@ -0,0 +1,278 @@
+const fs = require('fs').promises;
+const path = require('path');
+const vm = require('vm');
+const Config = require("@cocreate/config");
+const { URL } = require('url');
+
+const organizations = {};
+const hosts = {};
+
+class CoCreateLazyLoader {
+    constructor(server, crud, files) {
+        this.server = server
+        this.wsManager = crud.wsManager
+        this.crud = crud
+        this.files = files
+        this.exclusion = { ...require.cache };
+        this.modules = {};
+        this.init()
+    }
+
+    async init() {
+        // Function to create the scripts directory if it doesn't exist
+        async function createScriptsDirectory() {
+            try {
+                const scriptsDirectory = './scripts';
+                await fs.mkdir(scriptsDirectory, { recursive: true });
+                console.log(`Scripts directory created at ${scriptsDirectory}`);
+            } catch (error) {
+                console.error('Error creating scripts directory:', error);
+                throw error; // Halt execution if directory creation fails
+            }
+        }
+
+        // Call this function at the start of your application
+        createScriptsDirectory();
+
+        // TODO: return the value so it can be applied directly to modules
+        // this.modules[key] = await Config('modules', false, false)
+
+        const config = await Config('modules', false, false)
+        if (!config)
+            return
+
+        for (let name of Object.keys(config.modules)) {
+            this.modules[name] = config.modules[name];
+            this.wsManager.on(this.modules[name].event, async (data) => {
+                this.executeScriptWithTimeout(name, data)
+            });
+        }
+
+        this.server.on('request', async (req, res) => {
+            try {
+                const valideUrl = new URL(`http://${req.headers.host}${req.url}`);
+                const hostname = valideUrl.hostname;
+
+                let organization = hosts.get(hostname);
+                if (!organization) {
+                    let org = await this.crud.send({
+                        method: 'object.read',
+                        array: 'organizations',
+                        $filter: {
+                            query: [
+                                { key: "host", value: [hostname], operator: "$in" }
+                            ]
+                        },
+                        organization_id: process.env.organization_id
+                    })
+
+                    if (!org || !org.object || !org.object[0]) {
+                        if (!hostNotFound)
+                            hostNotFound = await getDefaultFile('/hostNotFound.html')
+                        return sendResponse(hostNotFound.object[0].src, 404, { 'Content-Type': 'text/html', 'storage': organization.storage })
+                    } else {
+                        organization = org.object[0]
+                        organizations[organization._id] = organization
+                        hosts[hostname] = organization
+                    }
+                }
+
+                if (valideUrl.pathname.startsWith('/webhooks/')) {
+                    let name = req.url.split('/')[2]; // Assuming URL structure is /webhook/name/...
+                    if (this.modules[name]) {
+                        this.executeScriptWithTimeout(name, { req, res, crud: this.crud, organization, valideUrl })
+                    } else {
+                        // Handle unknown module or missing webhook method
+                        res.writeHead(404, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Not found' }));
+                    }
+
+                } else {
+                    this.files.send(req, res, this.crud, organization, valideUrl)
+                }
+
+            } catch (error) {
+                res.writeHead(400, { 'Content-Type': 'text/plain' });
+                res.end('Invalid host format');
+            }
+
+
+        })
+
+    }
+
+    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].content) {
+                data.apis = await this.getApiKey(data.organization_id, name)
+                data = await this.modules[name].content.send(data)
+                delete data.apis
+                if (data.socket)
+                    this.wsManager.send(data)
+            } else
+                return
+
+            if (this.modules[name].unload === false || this.modules[name].unload === 'false')
+                return
+            else if (this.modules[name].unload === true || this.modules[name].unload === 'true')
+                console.log('config should unload after completeion ')
+            else if (this.modules[name].unload = parseInt(this.modules[name].unload, 10)) {
+                // Check if the script is already loaded
+                if (this.modules[name].timeout) {
+                    clearTimeout(this.modules[name].timeout);
+                } else if (!this.modules[name].path) {
+                    // Execute the script
+                    this.modules[name].context = new vm.createContext({});
+                    const script = new vm.Script(this.modules[name].context);
+                    script.runInContext(context);
+                }
+
+                // Reset or set the timeout
+                const timeout = setTimeout(() => {
+                    // delete this.modules[name]
+                    delete this.modules[name].timeout
+                    delete this.modules[name].context
+                    delete this.modules[name].content
+                    console.log(`Module ${name} removed due to inactivity.`);
+                    clearModuleCache(name);
+
+                }, this.modules[name].unload);
+
+                this.modules[name].timeout = timeout
+            }
+        } catch (error) {
+            console.log(error)
+        }
+    }
+
+    async getApiKey(organization_id, name) {
+        organizations[organization_id] = this.getOrganization(organization_id, name)
+        organizations[organization_id] = await organizations[organization_id]
+        return organizations[organization_id][name]
+    }
+
+    async getOrganization(organization_id) {
+        let organization = await this.crud.send({
+            method: 'object.read',
+            database: organization_id,
+            array: 'organizations',
+            object: [{ _id: organization_id }],
+            organization_id
+        })
+
+        if (organization
+            && organization.object
+            && organization.object[0]) {
+            if (organization.object[0].apis) {
+                return organization.object[0].apis
+            } else
+                return { error: 'No apis defined could not be found' }
+        } else {
+            return { serverOrganization: false, error: 'An organization could not be found' }
+        }
+
+    }
+
+
+}
+
+function getModuleDependencies(modulePath) {
+    let moduleObj = require.cache[modulePath];
+    if (!moduleObj) {
+        return [];
+    }
+
+    // Get all child module paths
+    return moduleObj.children.map(child => child.id);
+}
+
+function isModuleUsedElsewhere(modulePath, name) {
+    return Object.keys(require.cache).some(path => {
+        const moduleObj = require.cache[path];
+        // return moduleObj.children.some(child => child.id === modulePath && path !== modulePath);
+        return moduleObj.children.some(child => {
+            // let test = child.id === modulePath && path !== modulePath
+            // if (test)
+            //     return test
+            return child.id === modulePath && path !== modulePath
+        });
+    });
+}
+
+function clearModuleCache(name) {
+    try {
+        const modulePath = require.resolve(name);
+        const dependencies = getModuleDependencies(modulePath);
+
+        // Check if the module is a dependency of other modules
+        // const moduleObj = require.cache[modulePath];
+        // if (moduleObj && moduleObj.parent) {
+        //     console.log(`Module ${name} is a dependency of other modules.`);
+        //     return;
+        // }
+
+        // Check if the module is used by other modules
+        if (isModuleUsedElsewhere(modulePath, name)) {
+            console.log(`Module ${name} is a dependency of other modules.`);
+            return;
+        }
+
+        // Remove the module from the cache
+        delete require.cache[modulePath];
+        console.log(`Module ${name} has been removed from cache.`);
+        // Recursively clear dependencies from cache
+        dependencies.forEach(depPath => {
+            clearModuleCache(depPath);
+        });
+
+    } catch (error) {
+        console.error(`Error clearing module cache for ${name}: ${error.message}`);
+    }
+}
+
+// Function to fetch script from database and save to disk
+async function fetchScriptFromDatabaseAndSave(name, moduleConfig) {
+    let data = {
+        method: 'object.read',
+        array: moduleConfig.array,
+        $filter: {
+            query: [
+                { key: "host", value: [moduleConfig.object.hostname, '*'], operator: "$in" },
+                { key: "pathname", value: moduleConfig.object.pathname, operator: "$eq" }
+            ],
+            limit: 1
+        },
+        organization_id
+    };
+
+    let file = await this.crud.send(data);
+    let src;
+
+    if (file && file.object && file.object[0]) {
+        src = file.object[0].src;
+    } else {
+        throw new Error('Script not found in database');
+    }
+
+    // Save to disk for future use
+    const scriptPath = path.join(scriptsDirectory, `${name}.js`);
+    await fs.writeFile(scriptPath, src);
+
+    return src;
+}
+
+module.exports = CoCreateLazyLoader;