create-tinny-backend 1.0.0

package/index.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+const prompts = require('prompts');
+const { cyan, green, bold, yellow, red, gray } = require('kolorist');
+const ora = require('ora');
+
+
+const args = process.argv.slice(2);
+const projectName = args[0] || 'myapp';
+const targetDir = path.join(process.cwd(), projectName);
+
+
+if (fs.existsSync(targetDir)) {
+  console.error(red(`✖ Directory "${projectName}" already exists.`));
+  process.exit(1);
+}
+
+
+(async function main() {
+  console.log(cyan('\nWelcome to create-tinny-backend\n'));
+
+  const response = await prompts([
+    {
+      type: 'text',
+      name: 'description',
+      message: 'Project description',
+      initial: 'A tinny-backend application'
+    },
+    {
+      type: 'text',
+      name: 'author',
+      message: 'Author name',
+      initial: 'Yassine Ajagrou'
+    }
+  ]);
+
+
+  const templateDir = path.join(__dirname, 'template');
+  if (!fs.existsSync(templateDir)) {
+    console.error(red(`✖ Template folder not found at ${templateDir}`));
+    process.exit(1);
+  }
+
+  const spinner = ora('Copying template files...').start();
+  try {
+    fs.copySync(templateDir, targetDir);
+    spinner.succeed(green('Template copied successfully'));
+  } catch (err) {
+    spinner.fail(red('Failed to copy template'));
+    console.error(err);
+    process.exit(1);
+  }
+
+
+  const pkgPath = path.join(targetDir, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    const pkg = fs.readJsonSync(pkgPath);
+    pkg.name = projectName;
+    pkg.description = response.description || pkg.description;
+    pkg.author = response.author || pkg.author;
+    fs.writeJsonSync(pkgPath, pkg, { spaces: 2 });
+  }
+
+  const installSpinner = ora('Installing dependencies (npm install)...').start();
+  try {
+    execSync(`cd "${targetDir}" && npm install`, { stdio: 'pipe' });
+    installSpinner.succeed(green('Dependencies installed'));
+  } catch (err) {
+    installSpinner.fail(red('npm install failed'));
+    console.error(err);
+    process.exit(1);
+  }
+
+  const buildSpinner = ora('Building project (npm run build)...').start();
+  try {
+    execSync(`cd "${targetDir}" && npm run build`, { stdio: 'pipe' });
+    buildSpinner.succeed(green('Build completed'));
+  } catch (err) {
+    buildSpinner.fail(red('Build failed'));
+    console.error(err);
+    process.exit(1);
+  }
+
+  console.log(cyan('\n▶ Starting the server (npm run start)...\n'));
+  console.log(gray('Press Ctrl+C to stop the server when done.\n'));
+
+  try {
+    execSync(`cd "${targetDir}" && npm run start`, { stdio: 'inherit' });
+  } catch (err) {
+    console.log(yellow('\nServer stopped.'));
+    process.exit(0);
+  }
+
+  console.log(green(`\n✅ Project "${bold(projectName)}" is ready!`));
+  console.log(cyan(`   cd ${projectName}`));
+  console.log(cyan('   npm run dev   # for development with hot-reload'));
+  console.log(cyan('   npm start     # for production (already running)'));
+  console.log(gray('\n--------------------------------------------------'));
+  console.log(gray('Created by Yassine Ajagrou - https://github.com/iaceene'));
+  console.log(gray('--------------------------------------------------\n'));
+})().catch((err) => {
+  console.error(red('Unexpected error:'), err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "create-tinny-backend",
+  "version": "1.0.0",
+  "description": "Scaffold a new tinny-backend project",
+  "main": "index.js",
+  "bin": {
+    "create-tinny-backend": "./index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iaceene/create-tinny-backend.git"
+  },
+  "keywords": [
+    "tinny-backend",
+    "scaffold",
+    "starter",
+    "backend"
+  ],
+  "author": "Yassine Ajagrou",
+  "license": "ISC",
+  "type": "commonjs",
+  "bugs": {
+    "url": "https://github.com/iaceene/create-tinny-backend/issues"
+  },
+  "homepage": "https://github.com/iaceene/create-tinny-backend#readme",
+  "dependencies": {
+    "fs-extra": "^11.2.0",
+    "prompts": "^2.4.2",
+    "kolorist": "^1.8.0",
+    "ora": "^8.0.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/template/admin/auth.ts

@@ -0,0 +1,85 @@
+import * as JWT from "jsonwebtoken"
+import * as DOTENV from "dotenv"
+import Server from "tinny-backend";
+import type {
+    AdminSessions,
+    ServerReq,
+    ServerRes
+} from "tinny-backend"
+
+export type auth_t = {
+    Auth: (req: ServerReq, res: ServerRes) => Promise<void>;
+    sessions: AdminSessions[];
+    key: string;
+    SetUsername: (userName: string) => void;
+    SetPassword: (passWord: string) => void;
+    GetPasswd: () => string;
+    GetUser: () => string
+}
+
+export default function Authen(server: Server): auth_t{
+    DOTENV.config()
+    
+    let username: string = process.env.ADMIN_USERNAME || ""
+    let password: string = process.env.ADMIN_PASSWORD || ""
+    const key: string = process.env.ADMIN_KEY || ""
+    const sessions: AdminSessions[] = []
+    
+        
+    const isAuthed = (res: ServerRes): boolean =>{
+                const TOKEN = res.getCookie("token")
+                if (!TOKEN)
+                    return false
+                try {
+                    const decoded: any = JWT.default.verify(TOKEN.value, key);
+                    
+                    if (typeof decoded.id === undefined)
+                        throw new Error("None valid token");
+                    for (let i = 0; i < sessions.length; i++){
+                        if (sessions[i]?.id === decoded.id){
+                            if (!sessions[i]?.isValid)
+                                throw new Error("None valid token");
+                            (sessions[i] as AdminSessions).request += 1;
+                            (res as any).currentID = decoded.id;
+                            return true
+                        }
+                    }
+                    throw new Error("None valid UUID");
+                } catch {
+                    server.log("a user try to login to admin panel using none valid token", "error")
+                    return false
+                }
+                return true
+            }
+    
+    const Auth = async (req: ServerReq, res: ServerRes)=>{
+            if (!isAuthed(res)){
+                if (req.ReqUrl?.pathname == "/")
+                    return await  server.SendFile(res, "public/login/index.html", 401)
+                return await  server.SendFile(res, "public/status/401.html", 401)
+            }
+        
+            if (req.ReqUrl?.pathname == "/")
+                return await server.SendFile(res, "public/admin/index.html", 200)
+        }
+    
+    const SetUsername = (userName: string)=>{
+        console.log("old pwd ", username)
+        username = userName
+        console.log("new pwd ", username)
+    }
+
+    const SetPassword = (passWord: string)=>{
+        password = passWord
+    }
+
+    const GetPasswd = ()=>{
+        return password
+    }
+
+    const GetUser = ()=>{
+        return username
+    }
+
+    return {Auth, sessions, key, SetUsername, SetPassword, GetPasswd, GetUser}
+}

package/template/admin/monitor.ts

@@ -0,0 +1,102 @@
+import Server from "tinny-backend";
+import type {
+    ServerReq,
+    ServerRes
+} from "tinny-backend"
+import Authen from "./auth.js";
+import Routes from "./routes.js";
+
+export default function monitor(server: Server){
+        const {Auth, sessions, key, SetUsername, SetPassword, GetPasswd, GetUser} = Authen(server)
+        const { ChangeUser, LogoutSession, ChangePasswd, ChangePasswdAuth, CheckUsername, Status, Logout, Login } = Routes(server,  {Auth, sessions, key, SetUsername, SetPassword, GetPasswd, GetUser})
+
+
+        server.add({
+            method: "POST",
+            handler: Login,
+            path: "/api/login" 
+        })
+
+        server.add({
+            method: "GET",
+            middelWares: [Auth],
+            handler: async (req, res)=>{
+                return await  server.SendFile(res, "public/login/index.html", 200)
+            },
+            path: "/" 
+        })
+
+        server.add({
+            method: "GET",
+            middelWares: [Auth],
+            handler: Logout,
+            path: "/api/logout" 
+        })
+
+        server.add({
+            method: "GET",
+            middelWares: [Auth],
+            path: "/admin/status",
+            handler: Status
+        })
+
+        server.add({
+            method: "GET",
+            middelWares: [Auth],
+            path: "/messages",
+            handler: async (req: ServerReq, res: ServerRes) => {
+                res.send(200, {
+                    "logs" : server.getLogs()
+                })
+            }
+        })
+
+        server.add({
+            method: "GET",
+            path: "/passwd",
+            handler: async (req: ServerReq, res: ServerRes) => {
+                return await server.SendFile(res, "./public/login/new-password.html", 200)
+            }
+        })
+
+        server.add({
+            method: "GET",
+            path: "/api/passwd/:username",
+            handler: CheckUsername
+        })
+
+        server.add({
+            method: "POST",
+            path: "/api/passwd/change",
+            handler: ChangePasswd
+        })
+
+        server.add({
+            method: "POST",
+            middelWares: [Auth],
+            path: "/api/logout/:SessionId",
+            handler: LogoutSession
+        })
+
+        server.add({
+            method: "POST",
+            middelWares: [Auth],
+            path: "/passwd/change/auth",
+            handler: ChangePasswdAuth
+        })
+
+        server.add({
+            method: "POST",
+            middelWares: [Auth],
+            path: "/api/user/change",
+            handler: ChangeUser
+        })
+
+        server.servDir("./public/doc", "docs")
+        server.servDir("./public/imgs", "imgs")
+        server.servDir("./public/login", "/", [Auth])
+        server.servDir("./public/admin", "admin", [Auth])
+
+
+        server.listen(false)
+}

package/template/admin/routes.ts

@@ -0,0 +1,192 @@
+import * as os from "node:os";
+import * as JWT from "jsonwebtoken"
+import Server from "tinny-backend";
+import type {
+    AdminSessions,
+    ServerReq,
+    ServerRes
+} from "tinny-backend"
+
+import { type auth_t} from "./auth.js";
+
+
+
+export default function Routes(server: Server, obj: auth_t){
+
+    const {sessions, key, SetUsername, SetPassword, GetPasswd, GetUser} = obj
+
+
+    const Login = async (req: ServerReq, res: ServerRes) => {
+        let token
+                
+        try {
+                if (!req.body.username || req.body.username !== GetUser() || !req.body.password || req.body.password !== GetPasswd())
+                    throw new Error("User has entred a none valid cridentials")
+                const SESSION_ID = crypto.randomUUID()
+                token = JWT.default.sign({ id: SESSION_ID }, key, { expiresIn: "1h" });
+                res.addCookie("token", token)
+                sessions.push({
+                            id: SESSION_ID,
+                            isValid: true,
+                            creation: Date.now(),
+                            userAgent: req.headers["user-agent"] ?? "DEVICE",
+                            ip: (req as ServerReq).ip ?? "UNKNOWN",
+                            request: 0
+                        })
+                res.send(200, "./public/admin/index.html", { "set-cookie" : `token=${token}; Path=/; SameSite=Lax; HttpOnly` });
+            }
+            catch(err: any) {
+                    res.server.log(err.message, "error")
+                    res.server.log("A user entred a none valid cridentionl", "error")
+                    res.send(403, {"Error" : "Access Denied"})
+            }
+    }
+
+    const Logout = async (req: ServerReq, res: ServerRes) => {
+            let payloud: any
+            
+
+            const TOKEN = res.getCookie("token")
+            if (!TOKEN)
+                return server.SendFile(res, "public/login/index.html", 401)
+
+            try {
+                payloud = JWT.default.verify(TOKEN.value, key);
+                if (typeof payloud.id === "undefined")
+                    throw new Error("an Error is happens");
+                for (let i = 0; i < sessions.length; i++){
+                    if (sessions[i]?.id === payloud.id){
+                        if (!sessions[i]?.isValid)
+                            throw new Error("None valid token");
+                        (sessions[i] as AdminSessions).request += 1;
+                        (sessions[i] as AdminSessions).isValid = false;
+                        break;
+                    }
+                }
+                return await  server.SendFile(res, "public/login/index.html", 200)
+            }
+            catch(err: any) {
+                server.log(err.message, "error")
+                res.send(403, {"Error" : "Access Denied"})
+            }
+        }
+
+        const Status = async (req: ServerReq, res: ServerRes) => {
+                const now: number = Date.now()
+                res.send(200, {
+                    "Machin uptime": `${Math.floor(os.uptime() / 86400)}d ${Math.floor((os.uptime() % 86400) / 3600)}h ${Math.floor((os.uptime() % 3600) / 60)}m`,
+                    "Server uptime": `${Math.floor((now - server.getUpTime()) / (1000 * 60 * 60 * 24)) % 60}D ${Math.floor((now - server.getUpTime()) / (1000 * 60 * 60)) % 60}H ${Math.floor((now - server.getUpTime()) / (1000 * 60)) % 60}M ${Math.floor((now - server.getUpTime()) / 1000) % 60}S`,
+                    "Arch" : os.arch(),
+                    "Platform" : os.platform(),
+                    "Memory" : `${(os.totalmem() / (1024 ** 3)).toFixed(2)} GB`,
+                    "Used Memory" : `${((os.totalmem() - os.freemem()) / (1024 ** 3)).toFixed(2)} GB`,
+                    "Free Memory" : `${(os.freemem() / (1024 ** 3)).toFixed(2)} GB`,
+                    "Cpu" : os.cpus()[0],
+                    "Connected clients" : "0",
+                    "Total requests" : server.getReqCount(),
+                    "Currnet-session": (res as any).currentID,
+                    "sessions": sessions,
+                    "routes" : server.getMethodHandlers(),
+                    "logs" : server.getLogs()
+                })
+            }
+
+        const CheckUsername = async (req: ServerReq, res: ServerRes) => {
+                let userName = req.params.username
+
+                if (typeof userName === undefined)
+                    return res.send(404, {"user": userName, status: "not found"})
+
+                if (userName === GetUser())
+                    return res.send(200, {"user": userName, status: "found"})
+
+                return res.send(404, {"user": userName, status: "not found"})
+            }
+        
+        const ChangePasswd = async (req: ServerReq, res: ServerRes) => {
+                try {
+
+                    const { userName, oldpwd, newpwd } = req.body;
+
+                    if (!userName || !oldpwd || !newpwd)
+                        return res.send(400, { "user": userName || 'unknown', status: 'missing fields', message: 'Username, old password, and new password are required' });
+
+                    if (userName !== GetUser())
+                        return res.send(404, {"user": userName, status: 'this username not found', message: `${userName} not found` });
+
+                    if (oldpwd !== GetPasswd())
+                        return res.send(401, {"user": userName, status: 'password not corect', message: `Password not corect for ${userName}` });
+
+                    if (newpwd.length < 8)
+                        return res.send(400, { "user": userName, status: 'password must be 8 char +' });
+                    
+                    if (oldpwd === newpwd || newpwd === GetPasswd())
+                        return res.send(400, {"user": userName, status: 'new password must be different', message: 'New password must be different from current password' });
+                    SetPassword(newpwd)
+                    return res.send(200, { "user": userName, status: 'password changed', message: 'Password updated successfully'})
+
+                } catch(error: any) {
+                    server.log(`Password change error: ${error}`, "error");
+                    return res.send(500, { "user": req.body?.username || 'unknown', status: 'error', message: 'Internal server error'});
+                }
+            }
+
+        const LogoutSession = async (req: ServerReq, res: ServerRes) => {
+                let SessionID = req.params.SessionId
+
+                if (typeof SessionID === undefined)
+                    return res.send(404, {status: "not found"})
+
+                for (let i = 0; i < sessions.length; i++){
+                    if (SessionID === sessions[i]?.id){
+                        (sessions[i] as any).isValid = false;
+                        return res.send(200, {status: `session ${SessionID} logouted`})
+                    }
+                }
+                return res.send(404, {status: "not found"})
+            }
+
+        const ChangePasswdAuth = async (req: ServerReq, res: ServerRes) => {
+                try {
+                    const { oldpwd, newpwd } = req.body
+                    if (!oldpwd || !newpwd)
+                        return res.send(401, {status: "all field are required !"})
+
+                    if (oldpwd !== GetPasswd())
+                        return res.send(401, {status: "incorect password"})
+
+                    if (oldpwd === newpwd)
+                        return res.send(400, {status: "old pwd must be defrent from new one"})
+
+                    SetPassword(newpwd)
+                    return res.send(200, {status: "password changed with secc"})
+
+                } catch {
+                    res.send(500, {status: "internal server error"})
+                }
+                return res.send(401, {status: "?"})
+            }
+        
+        const ChangeUser = async (req: ServerReq, res: ServerRes) => {
+                try {
+                    const { userName } = req.body
+
+                    if (!userName)
+                        return res.send(401, {status: "all field are required !"})
+
+
+                    if (userName.length <= 3 || userName.length >= 20)
+                        return res.send(400, {status: "username must be between 4-19"})
+
+                    SetUsername(userName)
+                    return res.send(200, {status: "username changed with secc"})
+
+                } catch {
+                    res.send(500, {status: "internal server error"})
+                }
+                return res.send(401, {status: "?"})
+            }
+
+        return {ChangeUser, LogoutSession, ChangePasswd, ChangePasswdAuth, CheckUsername, Status, Logout, Login}
+}
+

package/template/app/index.ts

@@ -0,0 +1,6 @@
+import Server from "tinny-backend";
+import CreateServer from "../lib/CreateSrv.js";
+
+const srv = CreateServer(true, 3000);
+
+srv.listen()

package/template/lib/CreateSrv.ts

@@ -0,0 +1,9 @@
+import monitor from "../admin/monitor.js"
+import Server from "tinny-backend"
+
+export default function CreateServer(monitoring: boolean, PORT: number){
+    const server = new Server({port: PORT});
+    if (monitoring)
+        monitor(new Server({port: (PORT + 1)}))
+    return server;
+}

package/template/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "startup-tinny-backend",
+  "version": "1.0.0",
+  "description": "Backend starter using tinny-backend framework",
+  "private": false,
+  "main": "dist/app/index.js",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/app/index.js",
+    "dev": "nodemon dist/app/index.js",
+    "dev:watch": "ts-node-dev --respawn --transpile-only app/index.ts"
+  },
+  "engines": {
+    "node": ">=24.13.1",
+    "npm": ">=11.10.0"
+  },
+  "keywords": [
+    "backend",
+    "starter",
+    "tinny-backend",
+    "typescript"
+  ],
+  "author": "Yassine Ajagrou",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iaceene/startup-tinny-backend.git"
+  },
+  "bugs": {
+    "url": "https://github.com/iaceene/startup-tinny-backend/issues"
+  },
+  "homepage": "https://github.com/iaceene/startup-tinny-backend#readme",
+  "dependencies": {
+    "dotenv": "^17.4.2",
+    "jsonwebtoken": "^9.0.3",
+    "tinny-backend": "^1.0.3"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.10",
+    "nodemon": "^3.1.14",
+    "ts-node-dev": "^2.0.0"
+  },
+  "directories": {
+    "lib": "lib"
+  },
+  "types": "./dist/app/index.d.ts"
+}