kschema-fs-api-gen-post-actions 1.6.2

package/bin/v6/tasks/actions/InsertGenPk/steps/updateEndPointsJs.js

@@ -0,0 +1,16 @@
+import updateImports from "./UpdateRoutesJs/updateImports/index.js";
+import updateAppUse from "./UpdateRoutesJs/updateUse/index.js";
+
+const funcName = "getFunc";
+
+export default ({ appJsPath, endpoint }) => {
+    updateImports({
+        appJsPath, endpoint,
+        inFuncName: funcName
+    });
+
+    updateAppUse({
+        appJsPath, endpoint,
+        inFuncName: funcName
+    });
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/config/getSchema.js

@@ -0,0 +1,20 @@
+import fs from "fs";
+import path from "path";
+import { getConfig } from "../../core/configStore.js";
+
+export const getSchema = (table) => {
+    const config = getConfig();
+
+    const schemaPath = path.join(config.SchemaPath, `${table}.json`);
+
+    if (!fs.existsSync(schemaPath)) {
+        throw new Error(`Schema not found for table "${table}" at ${schemaPath}`);
+    }
+
+    try {
+        const schema = fs.readFileSync(schemaPath, "utf-8");
+        return JSON.parse(schema);
+    } catch (err) {
+        throw new Error(`Invalid schema JSON for "${table}": ${err.message}`);
+    };
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/controller.js

@@ -0,0 +1,27 @@
+import { startFunc as Service } from "./service.js";
+import { ConflictError, StorageError } from "./errors.js";
+
+const postFunc = async ({ req, res, inTablePath, inConfigPath }) => {
+    try {
+        const inRequestBody = req.body;
+
+        const fromService = await Service({
+            inRequestBody, inTablePath,
+            inConfigPath
+        });
+
+        res.type("application/json").send(fromService);
+    } catch (err) {
+
+        if (err instanceof ConflictError)
+            return res.status(409).send(err.message);
+
+        if (err instanceof StorageError)
+            return res.status(500).send("Failed to persist data");
+
+        console.error(err);
+        res.status(500).send("Unexpected error");
+    }
+};
+
+export default postFunc;

package/bin/v6/tasks/actions/InsertGenPk/template/v1/errors.js

@@ -0,0 +1,11 @@
+class AppError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+
+class ConflictError extends AppError { }
+class StorageError extends AppError { }
+
+export { AppError, ConflictError, StorageError };

package/bin/v6/tasks/actions/InsertGenPk/template/v1/getData.js

@@ -0,0 +1,11 @@
+import { JSONFilePreset } from 'lowdb/node'
+
+const startFunc = async ({ inTablePath }) => {
+    const db = await JSONFilePreset(inTablePath, []);
+
+    await db.read();
+
+    return await db.data;
+};
+
+export default startFunc;

package/bin/v6/tasks/actions/InsertGenPk/template/v1/getSchema.js

@@ -0,0 +1,11 @@
+import { JSONFilePreset } from 'lowdb/node'
+
+const startFunc = async ({ inConfigPath }) => {
+    const db = await JSONFilePreset(inConfigPath, {});
+
+    await db.read();
+
+    return await db.data;
+};
+
+export default startFunc;

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/buildMutate.js

@@ -0,0 +1,32 @@
+const insertAsIs = (mutate, tableName) => (record) =>
+    mutate.insertAsIs({ table: tableName, record });
+
+const insertFlat = (mutate, tableName) => (record) =>
+    mutate.insertFlat({ table: tableName, record });
+
+const insertGenPk = (mutate, tableName) => (record) =>
+    mutate.insertGenPk({ table: tableName, record });
+
+const insertWithChecks = (mutate, tableName) => (record) =>
+    mutate.insertWithChecks({ table: tableName, record });
+
+const deleteWithChecks = (mutate, tableName) => (pk) =>
+    mutate.deleteWithChecks({ table: tableName, pk });
+
+const deleteWhere = (mutate, tableName) => (where) =>
+    mutate.deleteWhere({ table: tableName, where });
+
+const updateWithChecks = (mutate, tableName) => (pk, record) =>
+    mutate.updateWithChecks({ table: tableName, pk, record });
+
+const buildMutate = (mutate, tableName) => ({
+    insertAsIs: insertAsIs(mutate, tableName),
+    insertFlat: insertFlat(mutate, tableName),
+    insertGenPk: insertGenPk(mutate, tableName),
+    insertWithChecks: insertWithChecks(mutate, tableName),
+    deleteWithChecks: deleteWithChecks(mutate, tableName),
+    deleteWhere: deleteWhere(mutate, tableName),
+    updateWithChecks: updateWithChecks(mutate, tableName)
+});
+
+export default buildMutate;

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/buildQuery.js

@@ -0,0 +1,32 @@
+import * as aggregate from "../engine/query/aggregate/index.js";
+
+const findAll = (query, tableName) => () =>
+    query.findAll({ table: tableName });
+
+const findByPk = (query, tableName) => (id) =>
+    query.findByPk({ table: tableName, id });
+
+const filterByPk = (query, tableName) => (id) =>
+    query.filterByPk({ table: tableName, id });
+
+const filterByColumns = (query, tableName) => (where) =>
+    query.filterByColumns({ table: tableName, where });
+
+const buildQuery = (query, tableName) => ({
+    findAll: findAll(query, tableName),
+    findByPk: findByPk(query, tableName),
+    filterByPk: filterByPk(query, tableName),
+    filterByColumns: filterByColumns(query, tableName),
+
+    aggregate: {
+        count: () =>
+            query.aggregate.count({ table: tableName }),
+        distinct: (column) =>
+            query.aggregate.distinct({
+                table: tableName,
+                column
+            })
+    }
+});
+
+export default buildQuery;

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/file/read.js

@@ -0,0 +1,7 @@
+import fs from "fs";
+
+export const readData = (path) => {
+    if (!fs.existsSync(path)) return [];
+
+    return JSON.parse(fs.readFileSync(path, "utf-8"));
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/file/write.js

@@ -0,0 +1,5 @@
+import fs from "fs";
+
+export const writeData = (path, data) => {
+    fs.writeFileSync(path, JSON.stringify(data, null, 2));
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/pkHelper.js

@@ -0,0 +1,19 @@
+export const getPrimaryKey = (columns) => {
+    const pkColumn = columns.find(c => c.primary);
+    if (!pkColumn) throw new Error("Primary key not defined");
+    return pkColumn.field;
+};
+
+export const attachPrimaryKey = (record, pk, data) => {
+    let maxId = 0;
+
+    for (const row of data) {
+        const val = Number(row[pk]) || 0;
+        if (val > maxId) maxId = val;
+    }
+
+    return {
+        ...record,
+        [pk]: maxId + 1
+    };
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/validate.js

@@ -0,0 +1,27 @@
+import required from "./validators/required.js";
+import type from "./validators/type.js";
+import minMax from "./validators/minMax.js";
+import length from "./validators/length.js";
+import enumCheck from "./validators/enum.js";
+import pattern from "./validators/pattern.js";
+import setDefault from "./validators/default.js";
+
+const validators = [required, type, minMax, length, enumCheck, pattern];
+
+const validate = (schema, record) => {
+    if (!schema?.columns) throw new Error("Invalid schema");
+
+    for (const col of schema.columns) {
+        if (!col.isConsider) continue;
+
+        setDefault(col, record); // 🔥 mutate first
+
+        const value = record[col.field];
+
+        for (const fn of validators) {
+            fn(col, value, record);
+        }
+    }
+};
+
+export default validate;

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/validateHelper.js

@@ -0,0 +1,27 @@
+export const validateRecord = (record, columns, data) => {
+    columns.forEach(col => {
+        const value = record[col.field];
+
+        if (col.required && (value === undefined || value === null || value === "")) {
+            throw new Error(`${col.field} is required`);
+        }
+
+        if (value === undefined) return;
+
+        if (col.unique && data.some(r => r[col.field] === value)) {
+            throw new Error(`${col.field} must be unique`);
+        }
+    });
+};
+
+export const validateFilterKeys = (filter, columns) => {
+    const validColumns = columns.map(col => col.field);
+
+    const invalidKeys = Object.keys(filter).filter(
+        key => !validColumns.includes(key)
+    );
+
+    if (invalidKeys.length > 0) {
+        throw new Error(`Invalid columns: ${invalidKeys.join(", ")}`);
+    };
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/validators/default.js

@@ -0,0 +1,5 @@
+export default (col, record) => {
+    if (record[col.field] == null && col.defaultValue !== undefined) {
+        record[col.field] = col.defaultValue;
+    }
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/validators/enum.js

@@ -0,0 +1,7 @@
+export default (col, value) => {
+    if (value == null || !col.enum) return;
+
+    if (!col.enum.includes(value)) {
+        throw new Error(`${col.field} must be one of ${col.enum.join(", ")}`);
+    }
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/validators/length.js

@@ -0,0 +1,11 @@
+export default (col, value) => {
+    if (value == null || typeof value !== "string") return;
+
+    if (col.minLength != null && value.length < col.minLength) {
+        throw new Error(`${col.field} min length ${col.minLength}`);
+    }
+
+    if (col.maxLength != null && value.length > col.maxLength) {
+        throw new Error(`${col.field} max length ${col.maxLength}`);
+    }
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/validators/minMax.js

@@ -0,0 +1,11 @@
+export default (col, value) => {
+    if (value == null) return;
+
+    if (col.min != null && value < col.min) {
+        throw new Error(`${col.field} must be >= ${col.min}`);
+    }
+
+    if (col.max != null && value > col.max) {
+        throw new Error(`${col.field} must be <= ${col.max}`);
+    }
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/validators/pattern.js

@@ -0,0 +1,8 @@
+export default (col, value) => {
+    if (value == null || !col.pattern) return;
+
+    const regex = new RegExp(col.pattern);
+    if (!regex.test(value)) {
+        throw new Error(`${col.field} format invalid`);
+    }
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/validators/required.js

@@ -0,0 +1,5 @@
+export default (col, value) => {
+    if ((col.isInput || col.primary) && (value === undefined || value === null || value === "")) {
+        throw new Error(`${col.field} is required`);
+    }
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/validators/type.js

@@ -0,0 +1,15 @@
+export default (col, value) => {
+    if (value == null) return;
+
+    if (col.type === "text" && typeof value !== "string") {
+        throw new Error(`${col.field} must be string`);
+    }
+
+    if (col.type === "number" && typeof value !== "number") {
+        throw new Error(`${col.field} must be number`);
+    }
+
+    if (col.type === "boolean" && typeof value !== "boolean") {
+        throw new Error(`${col.field} must be boolean`);
+    }
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/helpers/validators/unique.js

@@ -0,0 +1,8 @@
+export default (col, value, tableData) => {
+    if (!col.unique || value == null) return;
+
+    const exists = tableData?.some(r => r[col.field] === value);
+    if (exists) {
+        throw new Error(`${col.field} must be unique`);
+    }
+};

package/bin/v6/tasks/actions/InsertGenPk/template/v1/insertBase.js

@@ -0,0 +1,9 @@
+import { JSONFilePreset } from 'lowdb/node'
+
+const insertBase = async ({ inRequestBody, inTablePath }) => {
+    const db = await JSONFilePreset(inTablePath, []);
+
+    await db.update((posts) => posts.push(inRequestBody))
+};
+
+export default insertBase;

package/bin/v6/tasks/actions/InsertGenPk/template/v1/insertGenPk.js

@@ -0,0 +1,31 @@
+import insertBase from "./insertBase.js";
+import getData from "./getData.js";
+import getSchema from "./getSchema.js";
+import { getPrimaryKey, attachPrimaryKey } from "./helpers/pkHelper.js";
+
+const validateInput = ({ record }) => {
+    if (!record || typeof record !== "object") throw new Error("record must be object");
+};
+
+const insertGenPk = async ({ inRequestBody, inTablePath, inConfigPath }) => {
+    validateInput({ record: inRequestBody });
+
+    const schema = await getSchema({ inConfigPath });
+    const pk = getPrimaryKey(schema.columnsConfig);
+
+    if (inRequestBody[pk] !== undefined) {
+        return insertBase({ inRequestBody, inTablePath });
+    };
+
+    const data = await getData({ inTablePath });
+    const newRecord = attachPrimaryKey(inRequestBody, pk, data);
+
+    await insertBase({
+        inRequestBody: newRecord,
+        inTablePath
+    });
+
+    return newRecord[pk];
+};
+
+export default insertGenPk;

package/bin/v6/tasks/actions/InsertGenPk/template/v1/middleware.js

@@ -0,0 +1,19 @@
+const StartFunc = (req, res, next) => {
+    const LocalBody = req.body;
+
+    if (!LocalBody || Object.keys(LocalBody).length === 0) {
+        return res.status(400).send("Request body should not be empty.");
+    }
+
+    if (Array.isArray(LocalBody)) {
+        return res.status(400).send("Remove The Array From The Body.");
+    }
+
+    if (typeof LocalBody === 'object' && Object.keys(LocalBody).length === 0) {
+        return res.status(400).send("Request body should not be an empty object.");
+    }
+
+    next();
+};
+
+export { StartFunc };

package/bin/v6/tasks/actions/InsertGenPk/template/v1/rest.http

@@ -0,0 +1,7 @@
+
+POST http://localhost:3001/Api/v1/StockItems/WithMail
+Content-Type: application/json
+
+{
+      "StockItemName":"Rope 1 kg"
+}

package/bin/v6/tasks/actions/InsertGenPk/template/v1/service.js

@@ -0,0 +1,16 @@
+import insertGenPk from "./insertGenPk.js";
+import sendMail from "./Mail/sendMailCC.js";
+
+const startFunc = async ({ inRequestBody, inTablePath, inConfigPath }) => {
+    const insertedPk = await insertGenPk({ inRequestBody, inTablePath, inConfigPath });
+
+    const info = await sendMail();
+
+    return await {
+        insertedPk,
+        isMailSent: info.accepted.length > 0 &&
+            info.rejected.length === 0
+    };
+};
+
+export { startFunc };

package/bin/v6/tasks/actions/WithMail/actions.json

@@ -0,0 +1,26 @@
+    {
+        "cmd": "WithMail",
+        "file": "withMail",
+        "exportFile": "WithMail",
+        "group": "PostMethods",
+        "description": "Generate WithMail POST action",
+        "endPointsJs": {
+            "importLines": {
+                "toInsertLine": "import funcFromWithMail from './WithMail/controller.js';",
+                "duplicationCheck": "from './WithMail/controller.js'",
+                "insertAfter": [
+                    "import funcFrom",
+                    "import express"
+                ]
+            },
+            "useLines": {
+                "toInsertLine1": "router.get('/WithMail', (req, res) => funcFromWithMail({ res, inTablePath: tablePath }));",
+                "toInsertLine": "router.post('/WithMail', express.json(), (req, res) => funcFromWithMail({ req, res, inTablePath: tablePath, inConfigPath: configPath }));",
+                "duplicationCheck": "router.use('/WithMail'",
+                "insertAfter": [
+                    "router.",
+                    "const router = "
+                ]
+            }
+        }
+    }

package/bin/v6/tasks/actions/WithMail/steps/UpdateRoutesJs/common/readFile.js

@@ -0,0 +1,8 @@
+import fs from "fs";
+
+const readFile = (inAppJsPath) => {
+    const localPath = inAppJsPath;
+    return fs.readFileSync(localPath, "utf-8");
+};
+
+export default readFile;

package/bin/v6/tasks/actions/WithMail/steps/UpdateRoutesJs/common/writeFile.js

@@ -0,0 +1,10 @@
+import fs from "fs";
+
+const writeFile = (inAppJsPath, inContent) => {
+    const localPath = inAppJsPath;
+    const localContent = inContent;
+
+    fs.writeFileSync(localPath, localContent);
+};
+
+export default writeFile;

package/bin/v6/tasks/actions/WithMail/steps/UpdateRoutesJs/updateImports/buildImport.js

@@ -0,0 +1,9 @@
+const buildImport = ({ inFuncName, inEndpoint }) => {
+    const localEndpoint = inEndpoint;
+
+    const safeName = localEndpoint.replace(/[^a-zA-Z0-9]/g, "_");
+
+    return `import { ${inFuncName} } from "./${localEndpoint}/controller.js";`;
+};
+
+export default buildImport;

package/bin/v6/tasks/actions/WithMail/steps/UpdateRoutesJs/updateImports/checkDuplicate.js

@@ -0,0 +1,8 @@
+const checkUseDuplicate = ({ inContent, inFuncName }) => {
+    const localContent = inContent;
+    const toCheckLine = `import { ${inFuncName} } from`;
+
+    return localContent.includes(toCheckLine);
+};
+
+export default checkUseDuplicate;

package/bin/v6/tasks/actions/WithMail/steps/UpdateRoutesJs/updateImports/findInsertIndex.js

@@ -0,0 +1,10 @@
+const findInsertIndex = (inContent) => {
+    const localContent = inContent;
+
+    const matches = [...localContent.matchAll(/^\s*import.*$/gm)];
+    const last = matches.at(-1);
+
+    return last ? last.index + last[0].length : 0;
+};
+
+export default findInsertIndex;

package/bin/v6/tasks/actions/WithMail/steps/UpdateRoutesJs/updateImports/index.js

@@ -0,0 +1,47 @@
+import readFile from "../common/readFile.js";
+import buildImport from "./buildImport.js";
+import checkDuplicate from "./checkDuplicate.js";
+import findInsertIndex from "./findInsertIndex.js";
+import writeFile from "../common/writeFile.js";
+
+const updateImports = ({ appJsPath, endpoint, showLog, inFuncName }) => {
+    const summary = {
+        import: { added: false, line: null },
+    };
+
+    const content = readFile(appJsPath);
+
+    const importLine = buildImport({
+        inEndpoint: endpoint,
+        inFuncName
+    });
+
+    const fromCheckDuplicate = checkDuplicate({ inContent: content, inFuncName });
+
+    if (fromCheckDuplicate) {
+        summary.import.skipped = true;
+
+        if (showLog) console.log(summary);
+
+        return summary;
+    };
+
+    const index = findInsertIndex(content);
+
+    const before = content.slice(0, index);
+    const lineNumber = before.split("\n").length + 1;
+
+    const updated =
+        before + "\n" + importLine + content.slice(index);
+
+    writeFile(appJsPath, updated);
+
+    summary.import.added = true;
+    summary.import.line = lineNumber;
+
+    if (showLog) console.log(summary);
+
+    return summary;
+};
+
+export default updateImports;

package/bin/v6/tasks/actions/WithMail/steps/UpdateRoutesJs/updateUse/buildUseLine.js

@@ -0,0 +1,5 @@
+const buildUseLine = ({ inAppOrRouter, inEndpoint, inFuncName }) => {
+    return `${inAppOrRouter}.get('/${inEndpoint}', (req, res) => ${inFuncName}({ res, inTableName : tableName}));`;
+};
+
+export default buildUseLine;

package/bin/v6/tasks/actions/WithMail/steps/UpdateRoutesJs/updateUse/checkDuplicate.js

@@ -0,0 +1,9 @@
+const checkDuplicate = ({ inContent, inEndpoint, inAppOrRouter }) => {
+    const localContent = inContent;
+    const localEndpoint = inEndpoint;
+    const stringToSearch = `${inAppOrRouter}.get('/${localEndpoint}'`;
+
+    return localContent.includes(stringToSearch);
+};
+
+export default checkDuplicate;

package/bin/v6/tasks/actions/WithMail/steps/UpdateRoutesJs/updateUse/findInsertIndex.js

@@ -0,0 +1,10 @@
+const findUseInsertIndex = (inContent) => {
+    const localContent = inContent;
+
+    const matches = [...localContent.matchAll(/const\s+router\s*=\s*express\.Router\(\)/g)];
+    const match = matches.at(0);
+
+    return match ? match.index + match[0].length : localContent.length;
+};
+
+export default findUseInsertIndex;

package/bin/v6/tasks/actions/WithMail/steps/UpdateRoutesJs/updateUse/index.js

@@ -0,0 +1,56 @@
+import readFile from "../common/readFile.js";
+import writeFile from "../common/writeFile.js";
+
+import buildUseLine from "./buildUseLine.js";
+import checkDuplicate from "./checkDuplicate.js";
+import findUseInsertIndex from "./findInsertIndex.js";
+
+const appOrRouter = "router";
+
+const updateAppUse = ({ appJsPath, endpoint, showLog, inFuncName }) => {
+    const summary = {
+        use: { added: false, skipped: false, line: null }
+    };
+
+    const content = readFile(appJsPath);
+
+    const useLine = buildUseLine({
+        inAppOrRouter: appOrRouter,
+        inEndpoint: endpoint,
+        inFuncName
+    });
+
+    const fromCheckDuplicate = checkDuplicate({
+        inContent: content,
+        inEndpoint: endpoint,
+        inAppOrRouter: appOrRouter
+    });
+    console.log("fromCheckDuplicate : ", fromCheckDuplicate);
+
+    if (fromCheckDuplicate) {
+        summary.use.skipped = true;
+
+        if (showLog) console.log(summary);
+
+        return summary;
+    };
+
+    const index = findUseInsertIndex(content);
+
+    const before = content.slice(0, index);
+    const lineNumber = before.split("\n").length + 1;
+
+    const updated =
+        before + "\n" + useLine + content.slice(index);
+
+    writeFile(appJsPath, updated);
+
+    summary.use.added = true;
+    summary.use.line = lineNumber;
+
+    if (showLog) console.log(summary);
+
+    return summary;
+};
+
+export default updateAppUse;

package/bin/v6/tasks/actions/WithMail/steps/announce.js

@@ -0,0 +1,9 @@
+export const announce = ({ inResolvedFolderName }) => {
+    console.log(`[keshavsoft] Folder created: ${inResolvedFolderName}`);
+
+    console.log("");
+    console.log("Next:");
+    console.log("");
+    console.log(`cd ${inResolvedFolderName}`);
+    console.log(`npx kschema-api-gen AddSubRoute`);
+};