@keshavsoft/kschema-cli 1.11.1 → 1.12.1

package/bin/v12/commands/template/express/ForFrontEnd/NonSecured/Builder/main.js

@@ -0,0 +1,29 @@
+import { getNextVersion, createVersionFolder } from "./version.js";
+import { prepareRepo } from "./repo.js";
+import { readSchemas, injectSchema } from "./schema.js";
+import { buildProject } from "./build.js";
+import { publishSchema } from "./publish.js";
+
+function processSchema(versionPath, schema) {
+    console.log(`\nProcessing ${schema}`);
+    injectSchema(schema);
+    buildProject();
+    publishSchema(versionPath, schema);
+    console.log(`Done with ${schema}`);
+}
+
+function main() {
+    const version = getNextVersion();
+    console.log("Next Version:", version);
+
+    const versionPath = createVersionFolder(version);
+
+    prepareRepo();
+
+    const schemas = readSchemas();
+    schemas.forEach(s => processSchema(versionPath, s));
+
+    console.log("\n✔ All schemas processed successfully");
+}
+
+main();

package/bin/v12/commands/template/express/ForFrontEnd/NonSecured/Builder/publish.js

@@ -0,0 +1,22 @@
+import fs from "fs";
+import path from "path";
+import { CONFIG } from "./config.js";
+import { ensureDir, copyRecursive } from "./utils.js";
+
+export function publishSchema(versionPath, schemaFile) {
+    const schemaName = path.parse(schemaFile).name;
+    const targetDir = path.join(versionPath, schemaName);
+    const unProtectedDir = path.join(targetDir, "UnProtected");
+
+    ensureDir(unProtectedDir);
+
+    copyRecursive(
+        path.join(CONFIG.COMMON_REPO_PATH, "dist"),
+        unProtectedDir
+    );
+
+    fs.copyFileSync(
+        path.join(CONFIG.COMMON_REPO_PATH, "Menu", "index.html"),
+        path.join(targetDir, "index.html")
+    );
+}

package/bin/v12/commands/template/express/ForFrontEnd/NonSecured/Builder/repo.js

@@ -0,0 +1,20 @@
+import fs from "fs";
+import path from "path";
+import { CONFIG } from "./config.js";
+import { run } from "./utils.js";
+
+export function prepareRepo() {
+    if (!fs.existsSync(CONFIG.COMMON_REPO_PATH)) {
+        console.log(`${CONFIG.COMMON_REPO} not found. Cloning...`);
+        run(`git clone ${CONFIG.COMMON_REPO_GIT} ${CONFIG.COMMON_REPO_PATH}`);
+    }
+
+    if (!fs.existsSync(path.join(CONFIG.COMMON_REPO_PATH, "node_modules"))) {
+        console.log("Installing dependencies...");
+        run("npm install", CONFIG.COMMON_REPO_PATH);
+    }
+
+    if (fs.existsSync(".env")) {
+        fs.copyFileSync(".env", path.join(CONFIG.COMMON_REPO_PATH, ".env"));
+    }
+}

package/bin/v12/commands/template/express/ForFrontEnd/NonSecured/Builder/schema.js

@@ -0,0 +1,16 @@
+import fs from "fs";
+import path from "path";
+import { CONFIG } from "./config.js";
+
+export function readSchemas() {
+    const uiJson = fs.readFileSync(CONFIG.SCHEMA_FILE);
+    const parsed = JSON.parse(uiJson);
+    return parsed.Tables || [];
+}
+
+export function injectSchema(schemaFile) {
+    fs.copyFileSync(
+        path.join(CONFIG.SCHEMA_FOLDER, `${schemaFile}.json`),
+        path.join(CONFIG.COMMON_REPO_PATH, "schema.json")
+    );
+}

package/bin/v12/commands/template/express/ForFrontEnd/NonSecured/Builder/utils.js

@@ -0,0 +1,26 @@
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+
+export function run(cmd, cwd = process.cwd()) {
+    console.log(`> ${cmd}`);
+    execSync(cmd, { stdio: "inherit", cwd });
+}
+
+export function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+
+export function copyRecursive(src, dest) {
+    fs.readdirSync(src, { withFileTypes: true }).forEach(entry => {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+
+        if (entry.isDirectory()) {
+            ensureDir(destPath);
+            copyRecursive(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    });
+}

package/bin/v12/commands/template/express/ForFrontEnd/NonSecured/Builder/version.js

@@ -0,0 +1,25 @@
+import fs from "fs";
+import path from "path";
+import { CONFIG } from "./config.js";
+import { ensureDir } from "./utils.js";
+
+export function getNextVersion() {
+    let max = 0;
+
+    if (fs.existsSync(CONFIG.PUBLIC_DIR)) {
+        fs.readdirSync(CONFIG.PUBLIC_DIR, { withFileTypes: true })
+            .filter(d => d.isDirectory() && d.name.startsWith(CONFIG.VERSION_PREFIX))
+            .forEach(d => {
+                const n = parseInt(d.name.replace(CONFIG.VERSION_PREFIX, ""), 10);
+                if (!isNaN(n) && n > max) max = n;
+            });
+    }
+
+    return `${CONFIG.VERSION_PREFIX}${max + 1}`;
+};
+
+export function createVersionFolder(version) {
+    const versionPath = path.join(CONFIG.PUBLIC_DIR, version);
+    ensureDir(versionPath);
+    return versionPath;
+}

package/bin/v12/commands/template/express/ForFrontEnd/NonSecured/buildAndCopy.js

@@ -0,0 +1,166 @@
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+
+/* ================= CONFIG ================= */
+const CONFIG = {
+    PUBLIC_DIR: "Public",
+    VERSION_PREFIX: "V",
+    SCHEMA_FILE: "ui.json",
+    SCHEMA_FOLDER: "Schemas",
+    COMMON_REPO: "VoltUiGulpV1",
+    COMMON_REPO_GIT: "https://github.com/keshavsoft/VoltUiGulpV1"
+};
+
+CONFIG.COMMON_REPO_PATH = path.join("..", CONFIG.COMMON_REPO);
+/* ========================================== */
+
+/* ---------- GENERIC ---------- */
+const Utils = {
+    run(cmd, cwd = process.cwd()) {
+        console.log(`> ${cmd}`);
+        execSync(cmd, { stdio: "inherit", cwd });
+    },
+
+    ensureDir(dir) {
+        fs.mkdirSync(dir, { recursive: true });
+    },
+
+    copyRecursive(src, dest) {
+        fs.readdirSync(src, { withFileTypes: true }).forEach(entry => {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+
+            if (entry.isDirectory()) {
+                this.ensureDir(destPath);
+                this.copyRecursive(srcPath, destPath);
+            } else {
+                fs.copyFileSync(srcPath, destPath);
+            }
+        });
+    }
+};
+
+/* ---------- VERSION (Release Manager) ---------- */
+const Version = {
+    getNext() {
+        let max = 0;
+
+        if (fs.existsSync(CONFIG.PUBLIC_DIR)) {
+            fs.readdirSync(CONFIG.PUBLIC_DIR, { withFileTypes: true })
+                .filter(d => d.isDirectory() && d.name.startsWith(CONFIG.VERSION_PREFIX))
+                .forEach(d => {
+                    const n = parseInt(d.name.replace(CONFIG.VERSION_PREFIX, ""), 10);
+                    if (!isNaN(n) && n > max) max = n;
+                });
+        }
+
+        return `${CONFIG.VERSION_PREFIX}${max + 1}`;
+    },
+
+    createFolder(version) {
+        const versionPath = path.join(CONFIG.PUBLIC_DIR, version);
+        Utils.ensureDir(versionPath);
+        return versionPath;
+    }
+};
+
+/* ---------- REPO (Installer) ---------- */
+const Repo = {
+    ensureCloned() {
+        if (!fs.existsSync(CONFIG.COMMON_REPO_PATH)) {
+            console.log(`${CONFIG.COMMON_REPO} not found. Cloning...`);
+            Utils.run(`git clone ${CONFIG.COMMON_REPO_GIT} ${CONFIG.COMMON_REPO_PATH}`);
+        }
+    },
+
+    ensureDependencies() {
+        if (!fs.existsSync(path.join(CONFIG.COMMON_REPO_PATH, "node_modules"))) {
+            console.log("Installing dependencies...");
+            Utils.run("npm install", CONFIG.COMMON_REPO_PATH);
+        }
+    },
+
+    copyEnv() {
+        if (fs.existsSync(".env")) {
+            fs.copyFileSync(".env", path.join(CONFIG.COMMON_REPO_PATH, ".env"));
+        }
+    },
+
+    prepare() {
+        this.ensureCloned();
+        this.ensureDependencies();
+        this.copyEnv();
+    }
+};
+
+/* ---------- SCHEMA (Data Supplier) ---------- */
+const Schema = {
+    readAll() {
+        const uiJson = fs.readFileSync(CONFIG.SCHEMA_FILE);
+        const parsed = JSON.parse(uiJson);
+        return parsed.Tables || [];
+    },
+
+    inject(schemaFile) {
+        fs.copyFileSync(
+            path.join(CONFIG.SCHEMA_FOLDER, `${schemaFile}.json`),
+            path.join(CONFIG.COMMON_REPO_PATH, "schema.json")
+        );
+    }
+};
+
+/* ---------- BUILD (Compiler) ---------- */
+const Build = {
+    run() {
+        Utils.run("npm run NonSec", CONFIG.COMMON_REPO_PATH);
+    }
+};
+
+/* ---------- PUBLISH (Deployer) ---------- */
+const Publish = {
+    schema(versionPath, schemaFile) {
+        const schemaName = path.parse(schemaFile).name;
+        const targetDir = path.join(versionPath, schemaName);
+        const unProtectedDir = path.join(targetDir, "UnProtected");
+
+        Utils.ensureDir(unProtectedDir);
+
+        Utils.copyRecursive(
+            path.join(CONFIG.COMMON_REPO_PATH, "dist"),
+            unProtectedDir
+        );
+
+        fs.copyFileSync(
+            path.join(CONFIG.COMMON_REPO_PATH, "Menu", "index.html"),
+            path.join(targetDir, "index.html")
+        );
+    }
+};
+
+/* ---------- ORCHESTRATOR (Boss) ---------- */
+const App = {
+    processSchema(versionPath, schemaFile) {
+        console.log(`\nProcessing ${schemaFile}`);
+        Schema.inject(schemaFile);
+        Build.run();
+        Publish.schema(versionPath, schemaFile);
+        console.log(`Done with ${schemaFile}`);
+    },
+
+    run() {
+        const version = Version.getNext();
+        console.log("Next Version:", version);
+
+        const versionPath = Version.createFolder(version);
+
+        Repo.prepare();
+
+        const schemas = Schema.readAll();
+        schemas.forEach(schema => this.processSchema(versionPath, schema));
+
+        console.log("\n✔ All schemas processed successfully");
+    }
+};
+
+App.run();

package/bin/v12/commands/template/express/ForFrontEnd/NonSecured/latestVersion.js

@@ -0,0 +1,38 @@
+import fs from "fs";
+
+const PREFIX = "V";
+const ENV_FILE = ".env";
+
+/* -------- STEP 1: GET NEXT VERSION -------- */
+const dirs = fs.readdirSync("./", { withFileTypes: true })
+    .filter(d => d.isDirectory() && d.name.startsWith(PREFIX));
+
+let max = 0;
+
+dirs.forEach(d => {
+    const num = parseInt(d.name.replace(PREFIX, ""), 10);
+    if (!isNaN(num) && num > max) max = num;
+});
+
+const latestVersion = `${PREFIX}${max}`;
+console.log("Next Version:", latestVersion);
+
+/* -------- STEP 2: UPDATE .env -------- */
+let envContent = "";
+
+if (fs.existsSync(ENV_FILE)) {
+    envContent = fs.readFileSync(ENV_FILE, "utf8")
+        .split("\n")
+        .map(line =>
+            line.startsWith("VERSION=")
+                ? `VERSION=${latestVersion}`
+                : line
+        )
+        .join("\n");
+} else {
+    envContent = `VERSION=${latestVersion}\n`;
+};
+
+fs.writeFileSync(ENV_FILE, envContent);
+
+console.log(".env updated successfully ✔");

package/bin/v12/commands/template/express/ForFrontEnd/Secured/buildProtected.js

@@ -0,0 +1,108 @@
+import fs from "fs";
+import path from "path";
+
+import { execSync } from "child_process";
+
+/* ================= CONFIG ================= */
+const PUBLIC_DIR = "Public";
+const VERSION_PREFIX = "V";
+const SCHEMA_DIR = "ui.json";
+const COMMON_REPO = "VoltUiGulpV1";
+const COMMON_REPO_GIT = `https://github.com/keshavsoft/${COMMON_REPO}`;
+const COMMON_REPO_PATH = path.join("..", COMMON_REPO);
+/* ========================================== */
+
+function run(cmd, cwd = process.cwd()) {
+    console.log(`> ${cmd}`);
+    execSync(cmd, { stdio: "inherit", cwd });
+}
+
+/* ---------- STEP 1: GET NEXT VERSION ---------- */
+let max = 0;
+
+if (fs.existsSync(PUBLIC_DIR)) {
+    fs.readdirSync(PUBLIC_DIR, { withFileTypes: true })
+        .filter(d => d.isDirectory() && d.name.startsWith(VERSION_PREFIX))
+        .forEach(d => {
+            const n = parseInt(d.name.replace(VERSION_PREFIX, ""), 10);
+            if (!isNaN(n) && n > max) max = n;
+        });
+};
+
+const nextVersion = `${VERSION_PREFIX}${max + 1}`;
+console.log("Next Version:", nextVersion);
+
+const versionPath = path.join(PUBLIC_DIR, nextVersion);
+fs.mkdirSync(versionPath, { recursive: true });
+
+/* ---------- STEP 2: CLONE COMMON REPO ---------- */
+if (!fs.existsSync(COMMON_REPO_PATH)) {
+    console.log(`${COMMON_REPO} not found. Cloning...`);
+    run(`git clone ${COMMON_REPO_GIT} ${COMMON_REPO_PATH}`);
+}
+
+/* ---------- STEP 3: INSTALL DEPENDENCIES ---------- */
+if (!fs.existsSync(path.join(COMMON_REPO_PATH, "node_modules"))) {
+    console.log("node_modules not found. Running npm install...");
+    run("npm install", COMMON_REPO_PATH);
+}
+
+/* ---------- STEP 4: COPY .env ---------- */
+if (fs.existsSync(".env")) {
+    fs.copyFileSync(".env", path.join(COMMON_REPO_PATH, ".env"));
+}
+
+/* ---------- STEP 5: PROCESS SCHEMAS ---------- */
+const uiJson = fs.readFileSync(SCHEMA_DIR);
+const uiJsonParsed = JSON.parse(uiJson);
+
+uiJsonParsed.Tables.forEach(schemaFile => {
+    const schemaName = path.parse(schemaFile).name;
+    console.log(`\nProcessing ${schemaFile}`);
+
+    /* Copy schema */
+    fs.copyFileSync(
+        path.join("Schemas", `${schemaFile}.json`),
+        path.join(COMMON_REPO_PATH, "schema.json")
+    );
+
+    /* Build */
+    run("npm run NonSec", COMMON_REPO_PATH);
+
+    /* Target dirs */
+    const targetDir = path.join(versionPath, schemaName);
+    const protectedDir = path.join(targetDir, "UnProtected");
+
+    fs.mkdirSync(protectedDir, { recursive: true });
+
+    /* Copy dist */
+    copyRecursive(
+        path.join(COMMON_REPO_PATH, "dist"),
+        protectedDir
+    );
+
+    /* Copy menu */
+    fs.copyFileSync(
+        path.join(COMMON_REPO_PATH, "Menu", "index.html"),
+        path.join(targetDir, "index.html")
+    );
+
+    console.log(`Done with ${schemaFile}`);
+});
+
+console.log("\n✔ All schemas processed successfully");
+
+/* ---------- UTIL ---------- */
+function copyRecursive(src, dest) {
+    fs.readdirSync(src, { withFileTypes: true }).forEach(entry => {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+
+        if (entry.isDirectory()) {
+            fs.mkdirSync(destPath, { recursive: true });
+            copyRecursive(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    });
+};

package/bin/v12/commands/template/express/ForFrontEnd/Secured/latestVersion.js

@@ -0,0 +1,38 @@
+import fs from "fs";
+
+const PREFIX = "V";
+const ENV_FILE = ".env";
+
+/* -------- STEP 1: GET NEXT VERSION -------- */
+const dirs = fs.readdirSync("./", { withFileTypes: true })
+    .filter(d => d.isDirectory() && d.name.startsWith(PREFIX));
+
+let max = 0;
+
+dirs.forEach(d => {
+    const num = parseInt(d.name.replace(PREFIX, ""), 10);
+    if (!isNaN(num) && num > max) max = num;
+});
+
+const latestVersion = `${PREFIX}${max}`;
+console.log("Next Version:", latestVersion);
+
+/* -------- STEP 2: UPDATE .env -------- */
+let envContent = "";
+
+if (fs.existsSync(ENV_FILE)) {
+    envContent = fs.readFileSync(ENV_FILE, "utf8")
+        .split("\n")
+        .map(line =>
+            line.startsWith("VERSION=")
+                ? `VERSION=${latestVersion}`
+                : line
+        )
+        .join("\n");
+} else {
+    envContent = `VERSION=${latestVersion}\n`;
+};
+
+fs.writeFileSync(ENV_FILE, envContent);
+
+console.log(".env updated successfully ✔");

package/bin/v12/commands/template/express/app.js

@@ -0,0 +1,33 @@
+import { kschema } from "@keshavsoft/kschema";
+import consfigJson from './config.json' with { type: 'json' };
+
+kschema.loadConfig(consfigJson);
+
+import express from 'express';
+import http from 'http';
+
+const app = express();
+const server = http.createServer(app);
+
+var port = normalizePort(process.env.PORT || 3000);
+
+app.use(express.static('Public'));
+
+function normalizePort(val) {
+    var port = parseInt(val, 10);
+
+    if (isNaN(port)) {
+        return val;
+    }
+
+    if (port >= 0) {
+        return port;
+    }
+
+    return false;
+};
+
+server.listen(port, () => {
+    console.log(`Example app listening on port ${port}`);
+    console.log(`Open here http://localhost:${port}`);
+});

package/bin/v12/commands/template/express/config.json

@@ -0,0 +1,4 @@
+{
+    "DataPath": "Data",
+    "SchemaPath": "Config/Schemas"
+}

package/bin/v12/commands/template/express/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "KeshavSoft",
+  "version": "1.7.1",
+  "description": "",
+  "main": "app.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node --env-file=.env app.js"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@keshavsoft/kschema": "^1.6.1",
+    "body-parser": "^2.2.0",
+    "express": "^5.1.0"
+  }
+}

package/bin/v12/commands/test.js

@@ -0,0 +1,36 @@
+// commands/test.js
+
+import fs from "fs";
+import path from "path";
+
+export default (arg) => {
+    const projectPath = arg
+        ? path.resolve(process.cwd(), arg)
+        : process.cwd();
+
+    // 1. Check folder exists
+    if (!fs.existsSync(projectPath)) {
+        console.log("Invalid path");
+        return;
+    }
+
+    // 2. Check required structure
+    const hasConfigJson = fs.existsSync(
+        path.join(projectPath, "config.json")
+    );
+
+    const hasConfigFolder = fs.existsSync(
+        path.join(projectPath, "Config")
+    );
+
+    const hasSchemasFolder = fs.existsSync(
+        path.join(projectPath, "Config", "Schemas")
+    );
+
+    // 3. Final decision
+    if (hasConfigJson && hasConfigFolder && hasSchemasFolder) {
+        console.log("Already initialized");
+    } else {
+        console.log("Not initialized");
+    }
+};

package/bin/v12/core/parseInput.js

@@ -0,0 +1,10 @@
+export default function parseInput() {
+    const [cmd, ...args] = process.argv.slice(2);
+
+    return {
+        cmd: cmd || null,
+        args,
+        template: cmd || null,
+        folderName: args[0] || null,
+    };
+};

package/bin/v12/core/resolveCommand.js

@@ -0,0 +1,16 @@
+import init from "../commands/init.js";
+import test from "../commands/test.js";
+import generateSamples from "../commands/generateSamples.js";
+import express from "../commands/express.js";
+
+// resolveCommand.js
+const map = {
+    init,
+    test,
+    "generate-samples": generateSamples,
+    express
+};
+
+export default function resolveCommand(cmd) {
+    return map[cmd] || null;
+};

package/bin/v12/core/resolveFolderName.js

@@ -0,0 +1,17 @@
+import fs from "fs";
+
+export default function resolveFolderName({ name }) {
+    const defaultFolerName = `keshavsoft-basic-${Date.now()}`;
+
+    // case 1: force new → timestamp
+    if (name === null) {
+        name = defaultFolerName;
+    };
+
+    // case 2: user provided → strict
+    if (fs.existsSync(name)) {
+        throw new Error(`Folder already exists: ${name}`);
+    };
+
+    return name;
+};

package/bin/v12/core/showUsage.js

@@ -0,0 +1,42 @@
+/*
+KSchema CLI – Entry Flow
+
+1. Read user input from terminal (parseInput)
+2. If no command → show usage (first-time user safety)
+3. If help flags → show usage (quick guidance)
+4. Resolve command dynamically (no hardcoding logic)
+5. If command not found → inform + guide back to usage
+6. Execute command with parsed input
+
+Goal:
+- Zero confusion for user
+- Single source of truth (showUsage)
+- Easy to extend (just add commands, no core changes)
+*/
+
+export default function showUsage(version) {
+    const g = "\x1b[32m";
+    const y = "\x1b[33m";
+    const c = "\x1b[36m";
+    const gray = "\x1b[90m";
+    const r = "\x1b[0m";
+
+    console.log(`
+${c}🚀 KSchema CLI v${version}${r}
+
+${y}Usage:${r}
+  ${g}npx @keshavsoft/kschema-cli${r} <command> [options]
+
+${y}Commands:${r}
+  ${g}init${r}              Initialize a new schema setup
+  ${g}test${r}              Run schema validations/tests
+  ${g}generate-samples${r}  Generate sample schema files
+
+${y}Examples:${r}
+  ${gray}npx @keshavsoft/kschema-cli init${r}
+  ${gray}npx @keshavsoft/kschema-cli test users${r}
+
+${y}Tip:${r}
+  ${gray}npm i -g @keshavsoft/kschema-cli${r}
+`);
+}