npm - webfast - Versions diffs - 0.0.2 → 0.0.8 - Mend

webfast 0.0.2 → 0.0.8

Files changed (19) hide show

package/README.md +1 -1
package/ejs/example/link.ejs +25 -0
package/index.js +93 -52
package/modules/bots/applications/telegram/collect.js +3 -0
package/modules/bots/applications/telegram/middleware/message/location.js +14 -0
package/modules/bots/applications/telegram/middleware/message/start.js +10 -0
package/modules/bots/applications/telegram/send.js +18 -0
package/modules/bots/applications/telegram.js +275 -0
package/modules/bots/init.js +37 -0
package/modules/data/init.js +31 -0
package/modules/data/mongo/find.js +50 -0
package/modules/data/mongo/findOrCreate.js +62 -0
package/modules/express/init.js +23 -3
package/modules/express/routes/example/link.get.js +9 -2
package/modules/generator/init.js +1 -1
package/modules/request/functions/post.js +32 -0
package/modules/request/init.js +32 -0
package/package.json +3 -1
package/.vscode/launch.json +0 -17

package/README.md CHANGED Viewed

@@ -1,4 +1,4 @@
-# WebFast!
+# WebFast! **DEV**
 WebFast! is a lightweight, model-based framework developed by Hybrid Institute. It is designed for individuals who are interested in building no-code/low-code solutions and prefer an easy-to-setup development environment.

package/ejs/example/link.ejs ADDED Viewed

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><%= title %></title>
+</head>
+<body>
+    <h1>Hello, <%= name %>!</h1>
+    <% if (isAdmin) { %>
+        <p>Welcome, administrator!</p>
+    <% } else { %>
+        <p>You are not an administrator.</p>
+    <% } %>
+    <ul>
+        <% fruits.forEach(function(fruit) { %>
+            <li><%= fruit %></li>
+        <% }); %>
+    </ul>
+</body>
+</html>

package/index.js CHANGED Viewed

@@ -10,13 +10,15 @@ let program = {
 async function set(program) {
     program.path = await require(`path`);
     program.fs = await require(`fs`);
-    program.uuid = await require(`uuid`);
+    program.uuid = require(`uuid`);
+    program.fetch = require(`fetch`);
     return program;
 }
 // Program Fetch
 program.modules.dependOn = async function(reqFunc,program,name,callback) {
     console.log(`Depend On Check`);
     // Loop Through dependOn if its not true then check
     for (let dependIndex in reqFunc.dependOn) {
         const dependOn = reqFunc.dependOn[dependIndex];
@@ -32,9 +34,16 @@ program.modules.dependOn = async function(reqFunc,program,name,callback) {
             // Grab object
             let toCheck = split[spl];
             if (objectData[toCheck] == undefined) {
-                await setTimeout(async function(){
-                    return await program.modules.dependOn(reqFunc,program,name,callback);
-                },200);
+                if (program.modules[name] != undefined) {
+                    return;
+                } else {
+                    program.modules[name] = {
+                        ts : Date.now()
+                    }
+                    await setTimeout(async function(){
+                        await program.modules.dependOn(reqFunc,program,name,callback);
+                    },200);
+                }
             } else {
                 // New object thing and og next
                 if (split.length-1 != spl) {
@@ -53,15 +62,44 @@ program.modules.dependOn = async function(reqFunc,program,name,callback) {
             // We need to wait and try again untill we can return
             console.log(`DependOn Fail: ${dependOn}`);
             await setTimeout(async function(){
-                return await program.modules.dependOn(reqFunc,program);
+                await program.modules.dependOn(reqFunc,program);
             },200);
-        } else {
+        } else if (program.modules[reqFunc.name] == undefined) {
             console.log(`DependOn Succes: ${dependOn}`);
+            // Loop Through to find where data to set
+            const splitLoop = String(`${fullObjectPath}.${dependOnItem}`).split(`.`);
+            let object;
+            for (let s in splitLoop) {
+                let key = splitLoop[s];
+                try {
+                    if (object == undefined) {
+                        object = eval(key);
+                    } else {
+                        object = object[key];
+                    }
+                    if (s == splitLoop-1) {
+                        // It's end
+                        object = {
+                            depend : dependOn,
+                            state : true,
+                            ts : Date.now()
+                        }
+                    }
+                } catch (err) {
+                    console.error(err);
+                    console.error(`errror boject eval set`);
+                    return setTimeout(async function(){
+                        await program.modules.dependOn(reqFunc,program,name,callback);
+                    },200);
+                }
+            }
+            /*
             progData[dependOnItem] = {
                 depend : dependOn,
                 state : true,
                 ts : Date.now()
-            }
+            } */
             // Now include this thing then
             try {
@@ -121,7 +159,7 @@ program.modules.fetch = async function(folder,program) {
                         });
                     break;
                     case `function`:
-                        program = await (require(initPath)(program));
+                        program = await (require(initPath)(program,fileNameWithExtension));
                     break;
                     default:
                         console.error(`Error Missing typeOf item`);
@@ -135,67 +173,70 @@ program.modules.fetch = async function(folder,program) {
     }
 }
-program.modules.walkDirectory = async function (directoryPath,callback,forward) {
-    // Read the contents of the current directory
-    const files = await program.fs.readdirSync(directoryPath);
+program.modules.walkDirectory = async function (directoryPath, callback, forward) {
+    try {
+      // Read the contents of the current directory
+      const files = await program.fs.readdirSync(directoryPath);
-    let allFiles = [];
-    // Iterate through the files in the directory
-    for (let f in files) {
+      let allFiles = [];
+      // Iterate through the files in the directory
+      for (let f in files) {
         // Construct the full path of the current file or directory
         let file = files[f];
         const fullPath = await program.path.join(directoryPath, file);
         // Check if the current item is a directory
         const pathSync = await program.fs.statSync(fullPath);
         const isDirectoryPath = await pathSync.isDirectory();
         const fileExtension = await program.path.extname(fullPath);
         // Get the filename without the extension
         const fileName = await program.path.basename(fullPath, fileExtension);
         if (isDirectoryPath) {
-        // If it's a directory, recursively walk through it
-            let pushData = await program.modules.walkDirectory(fullPath,callback,fileName);
-            await allFiles.push(pushData);
+          // If it's a directory, recursively walk through it
+          let pushData = await program.modules.walkDirectory(fullPath, callback, fileName);
+          if (pushData.length !== 0) {
+            allFiles = allFiles.concat(pushData); // Concatenate arrays instead of pushing an array
+          }
         } else {
-            // If it's a file, print the path
-            // Get the file extension
-            console.log('File Extension:', fileExtension);
-            console.log('File Name:', fileName);
-            // Make Key from fileName extension
-            const fileData = {
-                extension : fileExtension,
-                name : fileName,
-                path : fullPath,
-                sub : []
-            }
-            if (forward != undefined) {
-                // PUsh it to sub
-                fileData.sub.push(forward);
-                return fileData;
-            } else {
-                await allFiles.push(fileData);
-            }
+          // If it's a file, print the path
+          console.log('File Extension:', fileExtension);
+          console.log('File Name:', fileName);
+          // Make Key from fileName extension
+          const fileData = {
+            extension: fileExtension,
+            name: fileName,
+            path: fullPath,
+            sub: [],
+          };
+          if (forward !== undefined) {
+            // Push it to sub
+            fileData.sub.push(forward);
+          } else {
+            allFiles.push(fileData);
+          }
         }
-    }
-    if (forward != undefined) {
+      }
+      if (forward !== undefined) {
         // Return data
-    }
-    if (callback && forward == undefined) {
+        return allFiles;
+      }
+      if (callback && forward === undefined) {
         await callback(allFiles);
-    } else {
+      } else {
         return allFiles;
+      }
+    } catch (error) {
+      console.error('Error:', error.message);
     }
-  }
+  };
 // Run program fetch

package/modules/bots/applications/telegram/collect.js ADDED Viewed

@@ -0,0 +1,3 @@
+module.exports = async function(program) {
+    console.log(`Collect Telegram Function`);
+}

package/modules/bots/applications/telegram/middleware/message/location.js ADDED Viewed

@@ -0,0 +1,14 @@
+module.exports = async function(req,res,body,params,command,middleValue) {
+    console.log(`Location Telegram Function`);
+    // We have the start function
+    let locSendMessage = `No Location Service Functions yet`;
+    if (middleValue.location != undefined) {
+        locSendMessage = `Thank you for sending your location\n ${middleValue.location.longitude}\n${middleValue.location.latitude}`;
+    }
+    return {
+        message : locSendMessage,
+        response : {
+            message : locSendMessage
+        }
+    }
+}

package/modules/bots/applications/telegram/middleware/message/start.js ADDED Viewed

@@ -0,0 +1,10 @@
+module.exports = async function(req,res,body,params,command,middleValue) {
+    console.log(`Start Telegram Function`);
+    // We have the start function
+    return {
+        response : {
+            message : `Thank you : ${command}`
+        }
+    }
+}

package/modules/bots/applications/telegram/send.js ADDED Viewed

@@ -0,0 +1,18 @@
+module.exports = async function(program,message,id) {
+    console.log(`Telegram Send`);
+    // Create Request for send
+    const telegramURL = `https://api.telegram.org/bot${process.env.telegram}/sendMessage`;
+    const body = {
+        text: message,
+        disable_web_page_preview: false,
+        disable_notification: false,
+        reply_to_message_id: null,
+        chat_id : id,
+        parse_mode : 'HTML'
+    }
+    const madeRequest = await program.modules.request.post(program,telegramURL,body)
+    console.log(`Send Message`);
+    return madeRequest;
+}

package/modules/bots/applications/telegram.js ADDED Viewed

@@ -0,0 +1,275 @@
+module.exports = async function(program,folder) {
+    console.log(`telegram application`);
+    const token = process.env.telegram;
+    // Create Adaptive URL
+    const adaptiveURL = `/api/${program.uuid.v4()}/telegram/hook`;
+    // Create request
+    const webhookURL = `${process.env.url}${adaptiveURL.slice(1)}`;
+    const telegramURL = `https://api.telegram.org/bot${token}/setWebhook`;
+    try {
+        const madeRequest = await program.modules.request.post(program,telegramURL,{
+            url : webhookURL
+        })
+        console.log(`Setup Telegram`,madeRequest);
+        // Set adaptive url get
+        program.express.url.set(adaptiveURL,`get`,async function(req,res,body,params){
+            console.log(`We have adaptive url get`);
+            res.send(`OK | GET`);
+            return true;
+        })
+        // Set adaptive url post
+        program.express.url.set(adaptiveURL,`post`,async function(req,res,body,params){
+            console.log(`We have adaptive url post`);
+            // set in collection telegram
+            // Process
+            let updateID;
+            for (let key in body) {
+                // Get Keys
+                if (key == `update_id`) {
+                    updateID = body[key];
+                } else {
+                    // /Try to find if this middleware is there
+                    try {
+                        // Try To Load it
+                        let middleValue = body[key];
+                        // Check for split
+                        // Try for message
+                        middleValue.chat.ts = Date.now();
+                        middleValue.chat.uuid = program.uuid.v4();
+                        let user = await program.modules.data.findOrCreate(`eventgo`,`telegram`,{
+                            id : middleValue.chat.id
+                        },middleValue.chat);
+                        let typeOFF = typeof user;
+                        if (middleValue.chat.uuid == user.uuid) {
+                            user.new = true;
+                        }
+                        middleValue.chat.uuid = user.uuid;
+                        try {
+                            if (middleValue.text.startsWith('/')) {
+                                // If it starts with a slash, it might be a command
+                                const parts = middleValue.text.split(' ');
+                                // The first part (index 0) will be the command, and the rest are potential variables
+                                const command = parts[0].slice(1);
+                                const variables = parts.slice(1)[0];
+                                console.log('Command:', command);
+                                console.log('Variables:', variables);
+                                // Define a regular expression pattern to match the different parts
+                                const regexPattern = /^([a-z]+)-([0-9a-f\-]+)-([a-z]+)$/;
+                                // Use the regular expression to match the parts
+                                let match;
+                                if (variables != undefined) {
+                                    match = variables.match(regexPattern);
+                                }
+                                if (match) {
+                                    // Extract the parts
+                                    const action = match[3];
+                                    const uuid = match[2];
+                                    const subFunction = match[1];
+                                    console.log('Action:', action);
+                                    console.log('UUID:', uuid);
+                                    console.log('Sub-Function:', subFunction);
+                                    // It's something to do check if we can find this in applications
+                                } else {
+                                    console.log('String does not match the expected pattern.');
+                                    // So run the function
+                                    try {
+                                        // Run dynamic the type of middleware
+                                        const runFunc   =   await program.modules.telegram.middleware[key][command](req,res,body,params,command,middleValue);
+                                        const respFunc = runFunc.response;
+                                        // PRocess response for object
+                                        const action = Object.keys(respFunc)[0];
+                                        // switch action
+                                        switch (action) {
+                                            case `message`:
+                                                console.log(`We have response, check for response message`);
+                                                const message = respFunc[action];
+                                                await program.modules.telegram.functions.send(program,message,middleValue.chat.id);
+                                            break;
+                                            default:
+                                                console.error(`Missing Response Action Telegram: ${action}`);
+                                        }
+                                    } catch (err) {
+                                        //console.error(err);
+                                        //console.error(`Error For Telegram Function`);
+                                        await program.modules.telegram.functions.send(program,`Unknown Command: ${command}`,middleValue.chat.id);
+                                    }
+                                }
+                                // Now you can handle the command and its associated variables as needed
+                                res.send(`OK | ${command} | ${variables}`)
+                                res.status(200);
+                            } else {
+                                // If it doesn't start with a slash, it might be something else
+                                //console.error('Not a command:', middleValue);
+                                // TODO Catch events for middleware now just respond
+                                const message = `${middleValue.text}`;
+                                const command = message;
+                                try {
+                                    // Run dynamic the type of middleware
+                                    const runFunc   =   await program.modules.telegram.middleware[key][command](req,res,body,params,command,middleValue);
+                                    const respFunc = runFunc.response;
+                                    // PRocess response for object
+                                    const action = Object.keys(respFunc)[0];
+                                    // switch action
+                                    switch (action) {
+                                        case `message`:
+                                            console.log(`We have response, check for response message`);
+                                            const message = respFunc[action];
+                                            await program.modules.telegram.functions.send(program,message,middleValue.chat.id);
+                                        break;
+                                        default:
+                                            console.error(`Missing Response Action Telegram: ${action}`);
+                                    }
+                                } catch (err) {
+                                    //console.error(err);
+                                    //console.error(`Error For Telegram Function`);
+                                    await program.modules.telegram.functions.send(program,`${command}`,middleValue.chat.id);
+                                }
+                                res.send(`OK`);
+                                res.status(200);
+                            }
+                        } catch (message) {
+                            // Process as other
+                            res.send(`OK | ${command} | ${variables}`)
+                            res.status(200);
+                            console.log(`Process Different`);
+                            let checkArray = [`location`];
+                            // Loop through checkArray
+                            for (let c in checkArray) {
+                                const command = checkArray[c];
+                                const indexCheck = Object.keys(middleValue).indexOf(command);
+                                if (indexCheck != -1) {
+                                    console.log(`Run this as middleware`);
+                                    try {
+                                        const runFunc   =   await program.modules.telegram.middleware[key][command](req,res,body,params,command,middleValue);
+                                        const respFunc = runFunc;
+                                        // PRocess response for object
+                                        if (respFunc == undefined) {
+                                            continue;
+                                        }
+                                        let action = Object.keys(respFunc)[0];
+                                        console.log(`The Action`);
+                                        switch (action) {
+                                            case `message`:
+                                                console.log(`We have response, check for response message`);
+                                                const message = respFunc[action];
+                                                await program.modules.telegram.functions.send(program,message,middleValue.chat.id);
+                                            break;
+                                            default:
+                                                console.error(`Missing Response Action Telegram: ${action}`);
+                                        }
+                                    } catch (err) {
+                                        console.error(err);
+                                        console.error(`Missing Function For Middleware`,middleware);
+                                        // Send error
+                                        res.send(`ERROR-2395343`);
+                                        res.status(500);
+                                    }
+                                }
+                            }
+                        }
+                    } catch (err) {
+                        console.error(err);
+                        console.error(`Error with loading message`);
+                        res.status(`ERROR-235235`);
+                        res.status(500);
+                    }
+                }
+            }
+            /*
+            res.send(`OK | POST`);
+            return;
+            */
+        });
+    } catch(err) {
+        console.error(err);
+        console.error(`Error Setting URL`);
+    }
+    const teleData = program.path.join(__dirname,`telegram`);
+    let moduleData = await program.modules.walkDirectory(teleData);
+    // Loop Through
+    let telegram = {
+        functions : {}
+    };
+    for (let index in moduleData) {
+        // Lets go
+        let module = moduleData[index];
+        let key = module.name;
+        // Try to load it
+        try {
+            telegram.functions[key] = require(module.path);
+            console.log(`Having The Module`,module);
+        } catch (err) {
+            console.error(err);
+            console.error(`Error Setting Up Telegram Module`);
+        }
+    }
+    let middleWareFolder = program.path.join(__dirname,`telegram`,`middleware`);
+    console.log(`MiddleWare:`,middleWareFolder);
+    let middleWareData = program.fs.readdirSync(middleWareFolder);
+    // Loop Through Middleware
+    let middleWarFuncs = {};
+    for (let mi in middleWareData) {
+        // Then loop through middlewarefolder for types
+        const middleWareName = middleWareData[mi];
+        let middleWareLoopFolder = program.path.join(middleWareFolder,middleWareName)
+        try {
+            let middleWareDataFolderLoop = program.fs.readdirSync(middleWareLoopFolder);
+            middleWarFuncs[middleWareName] = {};
+            for (let miN in middleWareDataFolderLoop) {
+                // Then loop through middlewarefolder for types
+                const fileName = middleWareDataFolderLoop[miN];
+                let middleWareLoopFolderSub = program.path.join(middleWareLoopFolder,fileName);
+                try {
+                    const requireFunc = require(middleWareLoopFolderSub);
+                    middleWarFuncs[middleWareName][fileName.split(`.`)[0]] = requireFunc;
+                    console.log(`Setted Middleware`);
+                } catch (err) {
+                    console.error(err);
+                    console.error(`Error Looping Message`);
+                }
+            }
+        } catch (err) {
+            console.error(err);
+            console.error(`Error Middle ware Telegram`);
+        }
+    }
+    // Add middleware
+    telegram.middleware = middleWarFuncs;
+    program.modules.telegram = telegram;
+    return program;
+}

package/modules/bots/init.js ADDED Viewed

@@ -0,0 +1,37 @@
+module.exports = {
+    dependOn : [`express.app`],
+    name : 'bot',
+    run : async function(program,name) {
+        console.log(`Running ${name}`);
+        // Scan bots folder and exclude
+        const routesPath = program.path.join(__dirname,`applications`);
+        let moduleData = await program.modules.walkDirectory(routesPath);
+        // We have the folder loop through
+        // Set Module
+        let setModule = {
+            ts : Date.now()
+        }
+        // loop Throuh module data
+        for (let moduleIndex in moduleData) {
+            // Get the module
+            let module = moduleData[moduleIndex];
+            // Create module in setModule
+            try {
+                // We have set module
+                const runModule = await require(module.path)(program,module);
+                setModule[module.name] = runModule;
+            } catch (err) {
+                console.error(err);
+                console.error(`Error Setting Module Data`,module.name);
+            }
+        }
+        // Put in program modules
+        program.modules[this.name] = setModule;
+        // Here we can do whatever like grab modules for generator and represent them here
+        return program;
+    }
+}

package/modules/data/init.js ADDED Viewed

@@ -0,0 +1,31 @@
+module.exports = async function (program,name){
+    console.log(`Running ${name}`);
+    // Lets make a mockup
+    const routesPath = program.path.join(__dirname,`mongo`);
+    let moduleData = await program.modules.walkDirectory(routesPath);
+    // Set Module
+    let setModule = {
+        ts : Date.now()
+    }
+    // loop Throuh module data
+    for (let moduleIndex in moduleData) {
+        // Get the module
+        let module = moduleData[moduleIndex];
+        // Create module in setModule
+        try {
+            // We have set module
+            setModule[module.name] = require(module.path);
+        } catch (err) {
+            console.error(`Error Setting Module Data`,module.name);
+        }
+    }
+    // Put in program modules
+    program.modules[name] = setModule;
+    // Here we can do whatever like grab modules for generator and represent them here
+    return program;
+}

package/modules/data/mongo/find.js ADDED Viewed

@@ -0,0 +1,50 @@
+const { MongoClient } = require('mongodb');
+module.exports = function(db,collection) {
+    // Ensure the MongoDB connection string is provided
+    if (!process.env.mongo) {
+        console.error('MongoDB connection string not provided. Set process.env.mongo.');
+        process.exit(1);
+    }
+    // Define the MongoDB URI
+    const uri = process.env.mongo;
+    // Define the database and collection name
+    const dbName = db;
+    const collectionName = collection;
+    // Define the query you want to perform
+    const query = { /* Your query goes here */ };
+    async function main() {
+    // Create a new MongoClient
+    const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
+    try {
+        // Connect to the MongoDB server
+        await client.connect();
+        console.log('Connected to the MongoDB server');
+        // Select the database
+        const database = client.db(dbName);
+        // Select the collection
+        const collection = database.collection(collectionName);
+        // Perform the find query
+        const result = await collection.find(query).toArray();
+        // Process the result
+        console.log('Query result:', result);
+    } finally {
+        // Close the MongoClient
+        await client.close();
+        console.log('Connection closed.');
+    }
+    }
+    // Execute the main function
+    main().catch(console.error);
+}

package/modules/data/mongo/findOrCreate.js ADDED Viewed

@@ -0,0 +1,62 @@
+const { MongoClient } = require('mongodb');
+module.exports = async function(db, collection, condition, dataToCreate) {
+    // Ensure the MongoDB connection string is provided
+    if (!process.env.mongo) {
+        console.error('MongoDB connection string not provided. Set process.env.mongo.');
+        process.exit(1);
+    }
+    // Define the MongoDB URI
+    const uri = process.env.mongo;
+    // Define the database and collection name
+    const dbName = db;
+    const collectionName = collection;
+    async function main() {
+        // Create a new MongoClient
+        const client = new MongoClient(uri);
+        try {
+            // Connect to the MongoDB server
+            await client.connect();
+            console.log('Connected to the MongoDB server');
+            // Select the database
+            const database = client.db(dbName);
+            // Select the collection
+            const collection = database.collection(collectionName);
+            // Check if a document exists based on the condition
+            const existingDocument = await collection.findOne(condition);
+            if (existingDocument) {
+                // If a document exists, return it
+                console.log('Document found:', existingDocument);
+                return existingDocument;
+            } else {
+                // If no document exists, create a new one
+                console.log('Document not found. Creating a new one.');
+                const result = await collection.insertOne(dataToCreate);
+                if (result.acknowledged === true) {
+                    console.log('New document created:', result.insertedId);
+                    const existingDocument = await collection.findOne(condition);
+                    return existingDocument;
+                } else {
+                    console.error('Failed to create a new document.');
+                    return null;
+                }
+            }
+        } finally {
+            // Close the MongoClient
+            await client.close();
+            console.log('Connection closed.');
+        }
+    }
+    // Execute the main function
+    return main().catch(console.error);
+};

package/modules/express/init.js CHANGED Viewed

@@ -127,11 +127,31 @@ module.exports = async function(program) {
         console.error(`Error Routes`);
     }
+    program.express.app = app;
     app.listen(port, () => {
         console.log(`Server Listening`,port,basePath);
     });
-    program.express.app = app;
+    // For creating adaptive url
+    program.express.url = {
+        adaptive : {
+            get : [],
+            post : []
+        },
+        set : function(requestPath,actionType,callback) {
+            // Callback is for when we run through adpative url
+            program.express.url.adaptive[actionType] = app[actionType](requestPath,async (req,res) => {
+                // Process body
+                let run = await callback(req,res,req.body,req.params);
+                return run;
+            });
+            return true;
+        }
+    }
+    program.express.setted = true;
     return program;
 }

package/modules/express/routes/example/link.get.js CHANGED Viewed

@@ -1,5 +1,12 @@
 module.exports = async function(program,req,res,route) {
     console.log(`Create`);
-    res.send(`OK`);
-    res.status(200);
+    const fullPath = program.path.join(__dirname, `..`,`..`,`..`,`..`,`ejs`,`example`,`link.ejs`);
+    // Render the EJS template
+    res.render(fullPath, {
+        title: 'EJS Example',
+        name: 'John Doe',
+        isAdmin: true,
+        fruits: ['Apple', 'Banana', 'Orange']
+    });
 }

package/modules/generator/init.js CHANGED Viewed

@@ -5,6 +5,6 @@ module.exports = {
         console.log(`Running ${name}`);
         // Here we can do whatever like grab modules for generator and represent them here
+        return program;
     }
 }

package/modules/request/functions/post.js ADDED Viewed

@@ -0,0 +1,32 @@
+module.exports = async function(program, url, body) {
+  console.log(`Fetch Post`);
+  // Register websocket url
+  try {
+      const headers = {
+          accept: 'application/json',
+          'content-type': 'application/json'
+      };
+      let theOptions = {
+          method: 'POST',
+          headers: headers,
+          body: JSON.stringify(body),
+      };
+      // Using standard fetch function
+      const response = await fetch(url, theOptions);
+      if (!response.ok) {
+          throw new Error(`HTTP error! Status: ${response.status}`);
+      }
+      const responseData = await response.json();
+      console.log('Response Data:', responseData);
+      // Return response data or true to indicate success
+      return responseData || true;
+  } catch (err) {
+      console.error('Error in post:', err.message);
+      return false;
+  }
+};

package/modules/request/init.js ADDED Viewed

@@ -0,0 +1,32 @@
+module.exports = async function(program,name) {
+        console.log(`Running ${name}`);
+        // Lets make a mockup
+        const routesPath = program.path.join(__dirname,`functions`);
+        let moduleData = await program.modules.walkDirectory(routesPath);
+        // Set Module
+        let setModule = {
+            ts : Date.now()
+        }
+        // loop Throuh module data
+        for (let moduleIndex in moduleData) {
+            // Get the module
+            let module = moduleData[moduleIndex];
+            // Create module in setModule
+            try {
+                // We have set module
+                setModule[module.name] = require(module.path);
+            } catch (err) {
+                console.error(`Error Setting Module Data`,module.name);
+                console.error(err);
+            }
+        }
+        // Put in program modules
+        program.modules.request = setModule;
+        // Here we can do whatever like grab modules for generator and represent them here
+        return program;
+    }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "webfast",
-  "version": "0.0.2",
+  "version": "0.0.8",
   "description": "WebFast!! Bot Application, including TON mini-apps",
   "main": "index.js",
   "repository": {
@@ -28,6 +28,8 @@
     "fetch": "^1.1.0",
     "fs": "^0.0.1-security",
     "js": "^0.1.0",
+    "mongodb": "^6.3.0",
+    "node-fetch": "^3.3.2",
     "path": "^0.12.7",
     "uuid": "^9.0.1"
   }

package/.vscode/launch.json DELETED Viewed

@@ -1,17 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Launch Program",
-            "skipFiles": [
-                "<node_internals>/**"
-            ],
-            "program": "${workspaceFolder}/index.js"
-        }
-    ]
-}