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

webfast 0.0.2 → 0.0.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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"
-        }
-    ]
-}