webfast 0.0.1

package/.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+    // 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"
+        }
+    ]
+}

package/README.md

@@ -0,0 +1,98 @@
+# WebFS
+
+WebFS 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.
+
+## Introduction
+
+WebFS provides a flexible and intuitive platform for creating web applications without the need for extensive coding. It empowers users to leverage a model-based approach, making it accessible to a broader audience, including those with limited coding experience.
+
+## Features
+
+- **Lightweight**: Keep your projects streamlined with a minimalistic approach.
+- **Model-Based**: Design and structure your applications using a model-driven paradigm.
+- **No-Code/Low-Code**: Build powerful applications with ease, even if you have limited coding experience.
+- **Easy to Setup**: Get started quickly with a straightforward setup process.
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js: Make sure you have Node.js installed. You can download it from [nodejs.org](https://nodejs.org/).
+
+### Installation
+
+1. Clone the repository:
+
+    ```bash
+    git clone https://github.com/ThePhotoCodeGrapher/WebFS.git
+    ```
+
+2. Navigate to the project directory:
+
+    ```bash
+    cd WebFS
+    ```
+
+3. Install dependencies:
+
+    ```bash
+    npm install
+    ```
+
+4. Configure the port:
+
+    - The default port is set to **1221** and can be changed in the file `/modules/express/init.js`. Open this file and modify the `PORT` variable according to your preference.
+
+5. Start the development server:
+
+    ```bash
+    npm start
+    ```
+
+6. Open your browser and visit [http://localhost:1221/api](http://localhost:1221/api) to explore the dynamically structured API endpoints based on your modules in `/modules/express/routes`.
+
+   - **Example Endpoint Structure**:
+     - `/api/example/link` (from `link.get.js` in `/modules/express/example`)
+     - `/api/example/{FOLDER_NAME}/{FILE_OR_FOLDER_NAME}` (based on your project structure)
+
+## Contributing
+
+We welcome contributions from the community. If you'd like to contribute to WebFS, please follow our [contribution guidelines](CONTRIBUTING.md).
+
+## Modules
+
+### Generator Module
+
+The `generator` module is an object-based component of WebFS that allows you to extend the functionality based on your specific requirements. This module will be automatically executed, taking into account its dependencies.
+
+#### Dependencies
+
+- `express.app`: This module is a prerequisite for the `generator` module.
+
+#### Usage
+
+The `generator` module exports an object with the following structure:
+
+```javascript
+module.exports = {
+    dependOn: ['express.app'],
+    name: 'generator',
+    run: function (program, name) {
+        console.log(`Running ${name}`);
+
+        // Here we can do whatever like grab modules for generator and represent them here
+    }
+}
+
+```
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Contact
+
+For questions or feedback, please feel free to [contact me on LinkedIn](https://linkedin.com/in/kaigartner). You can also reach out to me on Instagram: [@kaigartner](https://instagram.com/kaigartner).
+
+---
+
+**Hybrid Institute** - Empowering the future with innovative solutions.

package/index.js

@@ -0,0 +1,202 @@
+const { readdirSync } = require("fs");
+
+console.log(`WebFS! Program`);
+let program = {
+    ts  :   Date.now(),
+    modules : {}
+}
+
+// Setup The Requirements
+async function set(program) {
+    program.path = await require(`path`);
+    program.fs = await require(`fs`);
+    program.uuid = await require(`uuid`);
+    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];
+        // So we dependOn 
+        // Check index
+        // If .
+        let split = dependOn.split(`.`);
+        // Now we should loop through array
+        let objectData = program;
+        let fullObjectPath = `program`;
+        let dependOnItem = ``;
+        for (let spl in split) {
+            // Grab object
+            let toCheck = split[spl];
+            if (objectData[toCheck] == undefined) {
+                await setTimeout(async function(){
+                    return await program.modules.dependOn(reqFunc,program,name,callback);
+                },200);
+            } else {
+                // New object thing and og next
+                if (split.length-1 != spl) {
+                    fullObjectPath = fullObjectPath + `.${toCheck}`
+                } else {
+                    // Depend on
+                    dependOnItem = toCheck;
+                }
+                objectData = objectData[toCheck];
+            }
+        }
+
+        let progData = await eval(fullObjectPath);
+        const IndexCheck = Object.keys(progData).indexOf(dependOnItem);
+        if (IndexCheck == -1) {
+            // 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);
+            },200);
+        } else {
+            console.log(`DependOn Succes: ${dependOn}`);
+            progData[dependOnItem] = {
+                depend : dependOn,
+                state : true,
+                ts : Date.now()
+            }
+
+            // Now include this thing then
+            try {
+                program.modules[reqFunc.name] = await reqFunc.run(program,reqFunc.name);
+                if (callback != undefined) {
+                    return callback(program,name)
+                } else {
+                    return program;
+                }
+            } catch(err) {
+                // When erro
+                console.error(`Error Program add depend on require`);
+                console.error(err);
+            }
+        }
+    }
+}
+
+program.modules.fetch = async function(folder,program) {
+    // TO Fetch folder modules
+    program = await set(program);
+    try {
+        // Loop through folder and run module if js
+        const readPath = program.path.join(__dirname,folder);
+        const readDir = program.fs.readdirSync(readPath);
+        // Check if folder or not
+        await readDir.forEach(async (item) => {
+            const itemPath = program.path.join(readPath, item);
+            // Get the filename with extension
+            const fileNameWithExtension = program.path.basename(itemPath);
+
+            // Get the filename without extension
+            const fileNameWithoutExtension = program.path.parse(fileNameWithExtension).name;
+
+            console.log('Filename without extension:', fileNameWithoutExtension);
+
+            const isDirectory = program.fs.statSync(itemPath).isDirectory();
+
+            if (!isDirectory) {
+                // So it's file
+                // Run the file to know what to do but change program with the return
+                //program = (require(itemPath)(program));
+                //console.log(`Set`,itemPath);
+            } else {
+                // It's directory so read the init file
+                const initPath = program.path.join(itemPath,`init.js`);
+
+                // Require first
+                const reqFunc = require(initPath);
+                const theType = typeof reqFunc;
+                switch (theType) {
+                    case `object`:
+                        // It's a object so check for dependend things etc.
+                        console.log(`Depending object`);
+                        await program.modules.dependOn(reqFunc,program,fileNameWithoutExtension,function(program,name){
+                            console.log(`Setup `,name)
+                        });
+                    break;
+                    case `function`:
+                        program = await (require(initPath)(program));
+                    break;
+                    default:
+                        console.error(`Error Missing typeOf item`);
+                }
+            }
+        });
+
+    } catch(err) {
+        console.error(`Error Program Modules Fetch`);
+        console.error(err);
+    }
+}
+
+program.modules.walkDirectory = async function (directoryPath,callback,forward) {
+    // 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) {
+        // 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);
+        } 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 (forward != undefined) {
+        // Return data
+        
+    }
+    
+    if (callback && forward == undefined) {
+        await callback(allFiles);
+    } else {
+        return allFiles;
+    }
+  }
+  
+
+// Run program fetch
+program.modules.fetch(`modules`,program);

package/modules/express/init.js

@@ -0,0 +1,137 @@
+module.exports = async function(program) {
+    console.log(`Starting UP Express`);
+    program.express = {
+        ts : Date.now()
+    }
+
+    // Express and cors
+    const express = require('express');
+    const cors = require('cors');
+    const bodyParser = require('body-parser');
+    const port = 1221;
+    const basePath = `/api`;
+    
+    // Run Express
+    const app = express();
+
+    // Setup Cors
+    const corsOptions = {
+        origin: '*', // or specify your allowed origins
+        methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
+        credentials: true,
+        optionsSuccessStatus: 204,
+    };
+      
+    // Use Core Options
+    app.use(cors(corsOptions));
+
+    // Set View Engine
+    app.set('view engine', 'ejs');
+
+    // Enable bodyparser
+    app.use(bodyParser.json());
+    app.use(bodyParser.urlencoded({ extended: true }));
+
+    // Let's go through the folder routes and subdirectory
+    const routesPath = program.path.join(__dirname,`routes`);
+
+    let exprs = {};
+
+    try {
+        // Get routes for route path and setup the routes for express
+        let routesData = await program.modules.walkDirectory(routesPath);
+
+        // Loop Through routes
+        for (let rI in routesData) {
+            // Get the current route
+            let route = routesData[rI];
+            //console.log(`Route : `,route.path);
+
+            let routePath = `${basePath}`
+            // Loop Through sub and create path with basePath
+            for (let s in route.sub) {
+                routePath = `${routePath}/${route.sub[s]}`
+            }
+
+            // Check to split name
+            const split = route.name.split(`.`);
+            route.type = `get`;
+            if (split.length > 1) {
+                // we have a get or post
+                route.type = split[split.length-1];
+                route.name = split[0];
+            }
+
+            // FUll Route
+            routePath = `${routePath}/${route.name}`;
+
+            // Create Route UUID for easy findable
+            const routeID = program.uuid.v4();
+
+            // Setup ID
+            route.tempID = routeID;
+
+            // Setup the function
+            try {
+                route.func = require(route.path);
+            } catch(err) {
+                console.error(`Error Route Func`,routePath);
+                console.error(err);
+            }
+
+            // Save route for path
+            route.webwalk = 0;
+            exprs[routePath] = route;
+
+            console.log(`Setting Up Route`);
+        }
+
+        // Setted Up Routes
+        program.express.routes = exprs;
+
+        // Now we can setup the real shizzle for the post and get situation
+        //req,res,program
+        for (let route in exprs) {
+            // Setup route
+            let routeData = exprs[route];
+            console.log(`Setup Route`,route);
+            let state = false;
+            try {
+                // This is where the magic happens when we receive an incomming request it will 
+                // route it through the dynamice route folder
+                app[routeData.type](route,async (req,res) => {
+                    try {
+                        // Count walkthrough
+                        exprs[route].webwalk++;
+
+                        // Now passthrough func
+                        await routeData.func(program,req,res,route);
+                    } catch (err) {
+                        console.error(`Error With Route:`,route);
+                        console.error(err);
+                    }
+                });
+                state = true;
+            } catch (err) {
+                console.error(err);
+                console.error(`Error Setting Up Route`);
+            }
+
+            // Set state
+            exprs[route].state = state;
+        }
+
+        console.log(`We have routes`);
+    } catch (err) {
+        console.error(err);
+        console.error(`Error Routes`);
+    }
+
+
+    app.listen(port, () => {
+        console.log(`Server Listening`,port,basePath);
+    });
+    
+    program.express.app = app;
+    return program;
+}

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

@@ -0,0 +1,5 @@
+module.exports = async function(program,req,res,route) {
+    console.log(`Create`);
+    res.send(`OK`);
+    res.status(200);
+}

package/modules/generator/init.js

@@ -0,0 +1,10 @@
+module.exports = {
+    dependOn : [`express.app`],
+    name : 'generator',
+    run : function(program,name) {
+        console.log(`Running ${name}`);
+
+        // Here we can do whatever like grab modules for generator and represent them here
+        
+    }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "webfast",
+  "version": "0.0.1",
+  "description": "WebFS! Bot Application, including TON mini-apps",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ThePhotoCodeGrapher/webfs"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "event",
+    "go",
+    "mini",
+    "app",
+    "ton",
+    "telegram"
+  ],
+  "author": "Kai Gartner",
+  "license": "ISC",
+  "dependencies": {
+    "body-parser": "^1.20.2",
+    "cors": "^2.8.5",
+    "ejs": "^3.1.9",
+    "express": "^4.18.2",
+    "fetch": "^1.1.0",
+    "fs": "^0.0.1-security",
+    "js": "^0.1.0",
+    "path": "^0.12.7",
+    "uuid": "^9.0.1"
+  }
+}