@gudhub/core 1.1.111 → 1.1.112

package/GUDHUB/GHConstructor/createClassInstance.js

@@ -2,71 +2,115 @@ import axios from 'axios';
 import { IS_WEB } from './../consts.js';
 
 export default async function createClassInstance(gudhub, module_id, js_url, css_url, nodeWindow) {
-
     try {
-
-        // Check if there is url to javascript file of module
-
         if (!js_url) {
             console.error(`JS link must be provided for this data type - ${module_id}`);
         }
 
-        // Import module using dynamic import
-
-        let downloadModule = (url) => {
-            if (!IS_WEB && !global.hasOwnProperty('window')) {
-                global.window = proxy;
-                global.document = nodeWindow.document;
-                global.Element = nodeWindow.Element;
-                global.CharacterData = nodeWindow.CharacterData;
-                global.this = proxy;
-                global.self = proxy;
-                global.Blob = nodeWindow.Blob;
-                global.Node = nodeWindow.Node;
-                global.navigator = nodeWindow.navigator;
-                global.HTMLElement = nodeWindow.HTMLElement;
-                global.XMLHttpRequest = nodeWindow.XMLHttpRequest;
-                global.WebSocket = nodeWindow.WebSocket;
-                global.crypto = nodeWindow.crypto;
-                global.DOMParser = nodeWindow.DOMParser;
-                global.Symbol = nodeWindow.Symbol;
-                global.document.queryCommandSupported = (command) => {
-                    console.log('QUERY COMMAND SUPPORTED: ', command);
-                    return false;
+        // Safe global setter (skips read-only / getter-only props)
+        function setGlobal(name, value) {
+            const desc = Object.getOwnPropertyDescriptor(global, name);
+
+            if (!desc) {
+                try {
+                    Object.defineProperty(global, name, {
+                        value,
+                        writable: true,
+                        configurable: true,
+                        enumerable: true
+                    });
+                } catch (_) {}
+                return;
+            }
+
+            if (desc.writable || typeof desc.set === 'function') {
+                try { global[name] = value; } catch (_) {}
+            }
+            // Otherwise skip (non-writable / getter-only)
+        }
+
+        // Proxy for window to safely mirror properties to global
+        const proxy = (!IS_WEB && nodeWindow)
+            ? new Proxy(nodeWindow, {
+                get: (target, property) => {
+                    const value = target[property];
+                    if (typeof value === 'symbol') return undefined;
+                    return value;
+                },
+                set: (target, property, value) => {
+                    if (typeof value === 'symbol') return false;
+                    target[property] = value;
+                    setGlobal(property, value);
+                    return true;
+                }
+            })
+            : null;
+
+        // Load remote JS module and convert it to a data URI
+        const downloadModule = (url) => {
+            // Initialize globals once (Node environment only)
+            if (!IS_WEB && !Object.prototype.hasOwnProperty.call(global, 'window') && nodeWindow && proxy) {
+                setGlobal('window', proxy);
+                setGlobal('document', nodeWindow.document);
+                setGlobal('Element', nodeWindow.Element);
+                setGlobal('CharacterData', nodeWindow.CharacterData);
+                setGlobal('this', proxy);
+                setGlobal('self', proxy);
+                setGlobal('Blob', nodeWindow.Blob);
+                setGlobal('Node', nodeWindow.Node);
+                setGlobal('navigator', nodeWindow.navigator);
+                setGlobal('HTMLElement', nodeWindow.HTMLElement);
+                setGlobal('XMLHttpRequest', nodeWindow.XMLHttpRequest);
+                setGlobal('WebSocket', nodeWindow.WebSocket);
+                setGlobal('crypto', nodeWindow.crypto);
+                setGlobal('DOMParser', nodeWindow.DOMParser);
+                setGlobal('customElements', nodeWindow.customElements);
+
+                if (global.document) {
+                    try {
+                        global.document.queryCommandSupported = () => false;
+                    } catch (_) {}
                 }
-                global.angular = angular;
             }
-            return new Promise(async (resolve) => {
-                let moduleData = await axios.get(url).catch(err => {
-                    console.log(`Failed to fetch: ${url} in ghconstructor. Module id: ${module_id}`);
-                })
 
-                let encodedJs = encodeURIComponent(moduleData.data);
+            return new Promise(async (resolve, reject) => {
+                let moduleResp;
+                try {
+                    moduleResp = await axios.get(url);
+                } catch (err) {
+                    console.log(`Failed to fetch: ${url} in ghconstructor. Module id: ${module_id}`);
+                    return reject(err);
+                }
 
-                let dataUri = 'data:text/javascript;charset=utf-8,' + encodedJs;
+                if (!moduleResp || typeof moduleResp.data !== 'string') {
+                    return reject(new Error(`Empty or invalid JS for ${module_id} from ${url}`));
+                }
 
+                const encodedJs = encodeURIComponent(moduleResp.data);
+                const dataUri = 'data:text/javascript;charset=utf-8,' + encodedJs;
                 resolve(dataUri);
-            })
-        }
+            });
+        };
 
-        let moduleData = await downloadModule(js_url);
+        const moduleData = await downloadModule(js_url);
 
         let module;
-
         try {
-            module = await import(/* webpackIgnore: true */moduleData);
+            module = await import(/* webpackIgnore: true */ moduleData);
         } catch (err) {
             console.log(`Error while importing module: ${module_id}`);
             console.log(err);
         }
 
-        // Creating class from imported module
-
-        let importedClass = new module.default(module_id);
+        if (!module || !module.default) {
+            console.error(`Module ${module_id} didn't export a default class`);
+            return null;
+        }
 
-        // Check if there is url to css file of module
-        // If true, and there is no css for this data type, than create link tag to this css in head
+        // Create class instance
+        const importedClass = new module.default(module_id);
 
+        // Inject CSS in browser
         if (css_url && IS_WEB) {
             const linkTag = document.createElement('link');
             linkTag.href = css_url;
@@ -75,23 +119,19 @@ export default async function createClassInstance(gudhub, module_id, js_url, css
             document.getElementsByTagName('head')[0].appendChild(linkTag);
         }
 
-        let result = {
+        const result = {
             type: module_id,
 
-            //*************** GET TEMPLATE ****************//
-
-            getTemplate: function (ref, changeFieldName, displayFieldName, field_model, appId, itemId) {
-                let displayFieldNameChecked = displayFieldName === 'false' ? false : true;
+            getTemplate(ref, changeFieldName, displayFieldName, field_model, appId, itemId) {
+                const displayFieldNameChecked = displayFieldName === 'false' ? false : true;
                 return importedClass.getTemplate(ref, changeFieldName, displayFieldNameChecked, field_model, appId, itemId);
             },
 
-            //*************** GET DEFAULT VALUE ****************//
-
-            getDefaultValue: function (fieldModel, valuesArray, itemsList, currentAppId) {
+            getDefaultValue(fieldModel, valuesArray, itemsList, currentAppId) {
                 return new Promise(async (resolve) => {
-                    let getValueFunction = importedClass.getDefaultValue;
-                    if (getValueFunction) {
-                        let value = await getValueFunction(fieldModel, valuesArray, itemsList, currentAppId);
+                    const fn = importedClass.getDefaultValue;
+                    if (fn) {
+                        const value = await fn(fieldModel, valuesArray, itemsList, currentAppId);
                         resolve(value);
                     } else {
                         resolve(null);
@@ -99,24 +139,20 @@ export default async function createClassInstance(gudhub, module_id, js_url, css
                 });
             },
 
-            //*************** GET SETTINGS ****************//
-
-            getSettings: function (scope, settingType, fieldModels) {
+            getSettings(scope, settingType, fieldModels) {
                 return importedClass.getSettings(scope, settingType, fieldModels);
             },
 
-            //*************** FILTER****************//
-
             filter: {
-                getSearchOptions: function (fieldModel) {
-                    let d_type = importedClass;
+                getSearchOptions(fieldModel) {
+                    const d_type = importedClass;
                     if (d_type.filter && d_type.filter.getSearchOptions) {
                         return importedClass.filter.getSearchOptions(fieldModel);
                     }
                     return [];
                 },
-                getDropdownValues: function () {
-                    let d_type = importedClass;
+                getDropdownValues() {
+                    const d_type = importedClass;
                     if (d_type.filter && d_type.filter.getDropdownValues) {
                         return d_type.filter.getDropdownValues();
                     } else {
@@ -125,39 +161,32 @@ export default async function createClassInstance(gudhub, module_id, js_url, css
                 }
             },
 
-            //*************** GET INTERPRETATION ****************//
-
-            getInterpretation: function (value, interpretation_id, dataType, field, itemId, appId) {
+            getInterpretation(value, interpretation_id, dataType, field, itemId, appId) {
                 return new Promise(async (resolve) => {
-                    let currentDataType = importedClass;
+                    const currentDataType = importedClass;
 
                     try {
-                        let interpr_arr = await currentDataType.getInterpretation(gudhub, value, appId, itemId, field, dataType);
-                        let data = interpr_arr.find((item) => item.id == interpretation_id) || interpr_arr.find((item) => item.id == 'default');
+                        const interpr_arr = await currentDataType.getInterpretation(gudhub, value, appId, itemId, field, dataType);
+                        const data = interpr_arr.find((item) => item.id == interpretation_id) || interpr_arr.find((item) => item.id == 'default');
 
-                        let result = await data.content()
-
-                        resolve({ html: result });
+                        const html = await data.content();
+                        resolve({ html });
                     } catch (error) {
                         console.log(`ERROR IN ${module_id}`, error);
-                        resolve({ html: '<span>no interpretation</span>' })
+                        resolve({ html: '<span>no interpretation</span>' });
                     }
                 });
             },
 
-            //*************** GET INTERPRETATIONS LIST ****************//
-
-            getInterpretationsList: function (field_value, appId, itemId, field) {
+            getInterpretationsList(field_value, appId, itemId, field) {
                 return importedClass.getInterpretation(field_value, appId, itemId, field);
             },
 
-            //*************** GET INTERPRETATED VALUE ****************//
-
-            getInterpretatedValue: function (field_value, field_model, appId, itemId) {
+            getInterpretatedValue(field_value, field_model, appId, itemId) {
                 return new Promise(async (resolve) => {
-                    let getInterpretatedValueFunction = importedClass.getInterpretatedValue;
-                    if (getInterpretatedValueFunction) {
-                        let value = await getInterpretatedValueFunction(field_value, field_model, appId, itemId);
+                    const fn = importedClass.getInterpretatedValue;
+                    if (fn) {
+                        const value = await fn(field_value, field_model, appId, itemId);
                         resolve(value);
                     } else {
                         resolve(field_value);
@@ -165,47 +194,35 @@ export default async function createClassInstance(gudhub, module_id, js_url, css
                 });
             },
 
-            //*************** ON MESSAGE ****************//
-
-            onMessage: function(appId, userId, response) {
+            onMessage(appId, userId, response) {
                 return new Promise(async (resolve) => {
-                    const onMessageFunction = importedClass.onMessage;
-                    if(onMessageFunction) {
-                        const result = await onMessageFunction(appId, userId, response);
+                    const fn = importedClass.onMessage;
+                    if (fn) {
+                        const result = await fn(appId, userId, response);
                         resolve(result);
                     }
                     resolve(null);
-                })
+                });
             },
 
-            //*************** EXTEND CONTROLLER ****************//
-
-            extendController: function (actionScope) {
+            extendController(actionScope) {
                 importedClass.getActionScope(actionScope);
             },
 
-            //*************** RUN ACTION ****************//
-
-            runAction: function (scope) {
+            runAction(scope) {
                 try {
                     importedClass.runAction(scope);
-                } catch (e) {
-
-                }
+                } catch (e) {}
             },
 
-            //*************** GET WINDOW SCOPE ****************//
-
-            getWindowScope: function (windowScope) {
+            getWindowScope(windowScope) {
                 return importedClass.getWindowScope(windowScope);
             },
 
-            //*************** GET WINDOW HTML ****************//
-
-            getWindowHTML: function (scope) {
+            getWindowHTML(scope) {
                 return importedClass.getWindowHTML(scope);
             },
-        }
+        };
 
         return result;
 

package/GUDHUB/Storage/ModulesList.js

@@ -1088,6 +1088,13 @@ export default function generateModulesList(async_modules_path, file_server_url,
             type: 'automation',
             icon: 'automation_chat_gpt_thread'
         },
+        {
+            data_type: 'Deepseek',
+            name: 'Deepseek',
+            url: file_server_url + '/' + automation_modules_path + 'deepseek_node.js',
+            type: 'automation',
+            icon: 'automation_deepseek'
+        },
         {
             data_type: 'UrlToMarkdown',
             name: 'Url To Markdown',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gudhub/core",
-  "version": "1.1.111",
+  "version": "1.1.112",
   "description": "",
   "main": "index.js",
   "scripts": {