@keshavsoft/kschema-cli 1.11.1 → 1.12.1

package/bin/v12/commands/express/template/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/express/template/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/express/template/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/express/template/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/express/template/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/express/template/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/express/template/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/express/template/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/express/template/config.json

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

package/bin/v12/commands/express/template/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/express.js

@@ -0,0 +1,23 @@
+import { decideTemplate } from "./express/steps/decideTemplate.js";
+
+import { locateSource } from "./express/steps/locateSource.js";
+import { locateDestination } from "./express/steps/locateDestination.js";
+import { createProject } from "./express/steps/createProject.js";
+import { announce } from "./express/steps/announce.js";
+
+import resolveFolderName from "../core/resolveFolderName.js";
+
+export default ({ template, folderName }) => {
+    const finalTemplate = decideTemplate({ inTemplate: template });
+
+    const resolvedFolderName = resolveFolderName({
+        name: folderName
+    });
+
+    const source = locateSource({ template: finalTemplate });
+    const destination = locateDestination({ inResolvedFolderName: resolvedFolderName });
+
+    createProject({ source, destination });
+
+    announce({ inResolvedFolderName: resolvedFolderName });
+};

package/bin/v12/commands/generateSamples.js

@@ -0,0 +1,26 @@
+import fs from "fs";
+import path from "path";
+
+import { exampleSchema } from "@keshavsoft/kschema";
+import { baseTemplate } from "./template/baseTemplate.js";
+
+export default ({ args }) => {
+    const OUTPUT_DIR = path.resolve(process.cwd(), "samples");
+
+    if (!fs.existsSync(OUTPUT_DIR)) {
+        fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+    };
+
+    Object.entries(exampleSchema).forEach(([intent, methods]) => {
+        Object.entries(methods).forEach(([key, meta]) => {
+            if (Array.isArray(meta)) {
+                const finalCode = baseTemplate({
+                    body: meta.join("\r\n"),
+                    inTableName: args[0]
+                });
+
+                fs.writeFileSync(path.join(OUTPUT_DIR, `${intent}_${key}.js`), finalCode);
+            };
+        });
+    });
+};

package/bin/v12/commands/init/steps/announce.js

@@ -0,0 +1,3 @@
+export const announce = ({ inResolvedFolderName }) => {
+    console.log(`[keshavsoft] Project created: ${inResolvedFolderName}`);
+};

package/bin/v12/commands/init/steps/createProject.js

@@ -0,0 +1,7 @@
+import fs from "fs";
+
+export const createProject = ({ source, destination }) => {
+    fs.mkdirSync(destination, { recursive: true });
+
+    fs.cpSync(source, destination, { recursive: true });
+};

package/bin/v12/commands/init/steps/decideTemplate.js

@@ -0,0 +1,3 @@
+export const decideTemplate = ({ inTemplate }) => {
+    return inTemplate || "basic";
+};

package/bin/v12/commands/init/steps/locateDestination.js

@@ -0,0 +1,5 @@
+import path from "path";
+
+export const locateDestination = ({ inResolvedFolderName }) => {
+    return path.join(process.cwd(), inResolvedFolderName);
+};

package/bin/v12/commands/init/steps/locateSource.js

@@ -0,0 +1,13 @@
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const locateSource = () => {
+    return path.join(
+        __dirname,
+        "..",
+        "template"
+    );
+};

package/bin/v12/commands/init/template/.vscode/launch.json

@@ -0,0 +1,12 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Debug App",
+            "program": "${workspaceFolder}/app.js",
+            "envFile": "${workspaceFolder}/.env"
+        }
+    ]
+}