@keshavsoft/tallyextract 1.1.2 → 1.2.3

package/index.js

@@ -1 +1 @@
-export * from "./src/v1/index.js";
+export * from "./src/v3/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keshavsoft/tallyextract",
-  "version": "1.1.2",
+  "version": "1.2.3",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",

package/src/v3/api/Import/ledgers.json

@@ -0,0 +1,17 @@
+{
+    "static_variables": [
+        {
+            "name": "svExportFormat",
+            "value": "jsonex"
+        },
+        {
+            "name": "svCurrentCompany",
+            "value": "Mani9"
+        }
+    ],
+    "fetch_List": [
+        "Name",
+        "Parent",
+        "Closing Balance"
+    ]
+}

package/src/v3/api/PrepareDataObject/ForInventory/entryFile.js

@@ -0,0 +1,24 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import { startFunc as prepareInventory } from "./prepareInventory.js";
+// --------------------------------------------------
+
+// Creates inventory entries array from items.json
+const startFunc = ({ inItemsJsonAsArray }) => {
+    let LocalArray = [];
+    const LocalInItemsJsonAsArray = inItemsJsonAsArray;
+
+    return LocalInItemsJsonAsArray.map(element => {
+        return prepareInventory({
+            inItemName: element.ItemName,
+            inTaxPer: element.TaxPer,
+            inUom: element.Uom,
+            inRate: element.Rate,
+            inQty: element.Qty
+        });
+    });
+
+    return CommonFileDataAsJson;
+};
+
+export { startFunc };

package/src/v3/api/PrepareDataObject/ForInventory/prepareInventory.js

@@ -0,0 +1,85 @@
+import fs from "fs";
+import path from "path";
+
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const filePath = path.join(__dirname, "../../Import/Templates/inventory.json");
+
+// Prepares single inventory entry
+const startFunc = ({ inItemName, inTaxPer, inUom, inRate, inQty }) => {
+    // const filePath = path.join("./Import/Templates", "inventory.json");
+    let template = fs.readFileSync(filePath, "utf8");
+
+    let data = JSON.parse(template);
+
+    const LocalItemName = inItemName;
+    const LocalUom = inUom;
+    const LocalQty = inQty;
+    const LocalRate = inRate;
+
+    const LocalRateWithTax = LocalRate * (1 + (inTaxPer / 100));
+    const LocalAmount = LocalRate * LocalQty;
+
+    data.hsnitemsource = LocalItemName;
+    data.gstitemsource = LocalItemName;
+    data.stockitemname = LocalItemName;
+
+    data.mrprate = `${LocalRateWithTax}.00/${LocalUom}`;
+    data.inclvatrate = `${LocalRateWithTax}.00/${LocalUom}`;
+
+
+    // --------------------------------------------------
+    // Quantity & Amount
+    // --------------------------------------------------
+
+    data.amount = `${LocalAmount}.00`;
+    data.rate = `${LocalRate}.00/${LocalUom}`;
+    data.actualqty = `${LocalQty}.00 ${LocalUom}`;
+    data.billedqty = `${LocalQty}.00 ${LocalUom}`;
+
+
+    // --------------------------------------------------
+    // Batch Allocation
+    // --------------------------------------------------
+
+    data.batchallocations[0].amount = LocalRate * LocalQty;
+    data.batchallocations[0].actualqty = `${LocalQty}.00 ${LocalUom}`;
+    data.batchallocations[0].billedqty = `${LocalQty}.00 ${LocalUom}`;
+
+
+    // --------------------------------------------------
+    // Accounting Allocation
+    // --------------------------------------------------
+
+    data.accountingallocations[0].classrate = `${LocalRate}.00`;
+    data.accountingallocations[0].amount = `${LocalAmount}.00`;
+
+    updateRateDetails(data.ratedetails, inTaxPer);
+
+    return data;
+};
+
+// Update GST ratedetails safely
+const updateRateDetails = (ratedetails, taxPer) => {
+    const half = (taxPer / 2).toFixed(2);
+    const full = Number(taxPer).toFixed(2);
+
+    ratedetails.forEach(row => {
+        switch (row.gstratedutyhead) {
+            case "CGST":
+                row.gstrate = half;
+                break;
+            case "SGST/UTGST":
+                row.gstrate = half;
+                break;
+            case "IGST":
+                row.gstrate = full;
+                break;
+        }
+    });
+};
+
+export { startFunc };

package/src/v3/api/PrepareDataObject/ForLedger/entryFile.js

@@ -0,0 +1,46 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import { startFunc as prepareLedger } from "./prepareLedger.js";
+
+// Creates ledger entries for voucher
+const startFunc = ({ inItemsJsonAsArray, inLedgerDetails }) => {
+    let LocalArray = [];
+
+    const LocalInItemsJsonAsArray = inItemsJsonAsArray;
+
+    const LocalAmount = LocalInItemsJsonAsArray.map(element => {
+        return element.Rate * element.Qty * (1 + (element.TaxPer / 100));
+    });
+
+    const LocalOnlyAmount = LocalInItemsJsonAsArray.map(element => {
+        return element.Rate * element.Qty;
+    });
+
+    const amountSum = LocalAmount.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+    const onlyAmountSum = LocalOnlyAmount.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+
+    const LocalLedgerEntry = prepareLedger({
+        inLedgerName: inLedgerDetails.LedgerName,
+        inAmount: `-${amountSum}.00`
+    });
+
+    LocalArray.push(LocalLedgerEntry);
+
+    const LocalCGST = prepareLedger({
+        inLedgerName: "CGST Output",
+        inAmount: `${(amountSum - onlyAmountSum) / 2}.00`
+    });
+
+    LocalArray.push(LocalCGST);
+
+    const LocalSGST = prepareLedger({
+        inLedgerName: "SGST Output",
+        inAmount: `${(amountSum - onlyAmountSum) / 2}.00`
+    });
+
+    LocalArray.push(LocalSGST);
+
+    return LocalArray;
+};
+
+export { startFunc };

package/src/v3/api/PrepareDataObject/ForLedger/prepareLedger.js

@@ -0,0 +1,24 @@
+import fs from "fs";
+import path from "path";
+
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const filePath = path.join(__dirname, "../../Import/Templates/ledgers.json");
+
+// Prepares single ledger entry
+const startFunc = ({ inLedgerName, inAmount }) => {
+    // const filePath = path.join("./Import/Templates", "ledgers.json");
+    let template = fs.readFileSync(filePath, "utf8");
+
+    let data = JSON.parse(template);
+
+    data.ledgername = inLedgerName;
+    data.amount = inAmount;
+
+    return data;
+};
+
+export { startFunc };

package/src/v3/api/PrepareDataObject/entryFile.js

@@ -0,0 +1,20 @@
+import { startFunc as prepareClientData } from "./prepareClientData.js";
+import { startFunc as prepareTallyJson } from "./prepareTallyJson/entryFile.js";
+
+const startFunc = ({ inClientData }) => {
+    try {
+        let data = prepareTallyJson();
+
+        const fromClientData = prepareClientData({
+            inTallyJson: data,
+            inClientData
+        });
+
+        return fromClientData;
+    } catch (err) {
+        console.error("Import Failed");
+        console.log(err.response?.data || err.message);
+    };
+};
+
+export { startFunc };

package/src/v3/api/PrepareDataObject/prepareClientData.js

@@ -0,0 +1,56 @@
+import { startFunc as ForLedger } from "./ForLedger/entryFile.js";
+import { startFunc as ForInventory } from "./ForInventory/entryFile.js";
+
+const startFunc = ({ inTallyJson, inClientData }) => {
+    try {
+        let data = inTallyJson;
+
+        const LocalClientData = inClientData;
+
+        const LocalInventoryItem = ForInventory({ inItemsJsonAsArray: LocalClientData.allinventoryentries });
+
+        const LocalLedgerItem = ForLedger({
+            inItemsJsonAsArray: LocalClientData.allinventoryentries,
+            inLedgerDetails: LocalClientData.customerDetails
+        });
+
+        changeCustomerDetails({
+            inLedgerName: LocalClientData.customerDetails.LedgerName,
+            inData: data
+        });
+
+        changeVoucherDate({
+            inData: data,
+            inDate: LocalClientData.customerDetails.InvoiceDate
+        });
+
+        data.tallymessage[0].allinventoryentries = LocalInventoryItem;
+        data.tallymessage[0].ledgerentries = LocalLedgerItem;
+
+        return data;
+    } catch (err) {
+        console.error("Import Failed");
+        console.log(err.response?.data || err.message);
+    };
+};
+
+const changeCustomerDetails = ({ inLedgerName, inData }) => {
+    const CommonLedgerName = inLedgerName;
+
+    inData.tallymessage[0].partyname = CommonLedgerName;
+    inData.tallymessage[0].basicbuyername = CommonLedgerName;
+    inData.tallymessage[0].partyledgername = CommonLedgerName;
+    inData.tallymessage[0].consigneemailingname = CommonLedgerName;
+    inData.tallymessage[0].partymailingname = CommonLedgerName;
+    inData.tallymessage[0].basicbasepartyname = CommonLedgerName;
+};
+
+const changeVoucherDate = ({ inData, inDate }) => {
+    const localDate = inDate;
+
+    inData.tallymessage[0].date = localDate;
+    inData.tallymessage[0].vchstatusdate = localDate;
+    inData.tallymessage[0].effectivedate = localDate;
+};
+
+export { startFunc };

package/src/v3/api/PrepareDataObject/prepareTallyJson/entryFile.js

@@ -0,0 +1,25 @@
+import fs from "fs";
+import path from "path";
+
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const filePath = path.join(__dirname, "../../Import/Templates/template.json");
+
+const startFunc = () => {
+    try {
+        // const filePath = path.join("../../Import/Templates", "template.json");
+        let template = fs.readFileSync(filePath, "utf8");
+
+        let data = JSON.parse(template);
+
+        return data;
+    } catch (err) {
+        console.error("Import Failed");
+        console.log(err.response?.data || err.message);
+    };
+};
+
+export { startFunc };

package/src/v3/api/importVoucher.js

@@ -0,0 +1,14 @@
+import { sendToTally } from "../core/impotToTally.js";
+import { startFunc as PrepareDataObject } from "../api/PrepareDataObject/entryFile.js";
+
+import { validateImportVoucherInput } from "./utils/validateInput.js";
+
+const importVoucher = async (inClientData) => {
+    validateImportVoucherInput(inClientData);   // 🔥 early fail
+
+    const bodyToSend = PrepareDataObject({ inClientData });
+
+    return await sendToTally(bodyToSend);
+};
+
+export { importVoucher };

package/src/v3/api/index.js

@@ -0,0 +1,5 @@
+// src/v1/api/index.js
+export { ledger } from "./ledger.js";
+export { stockItems } from "./stockitems.js";
+
+export { importVoucher } from "./importVoucher.js";

package/src/{v1 → v3}/api/ledger.js

@@ -2,5 +2,5 @@
 import { sendToTally } from "../core/sendToTally.js";
 
 export function ledger() {
-    return sendToTally("KeshavStockItems");
+    return sendToTally("KeshavLedgers");
 };

package/src/v3/api/utils/validateInput.js

@@ -0,0 +1,36 @@
+// utils/validateInput.js
+const validateImportVoucherInput = (data) => {
+    if (!data || typeof data !== "object") {
+        throw new Error("Input must be an object");
+    }
+
+    // 🔹 allinventoryentries
+    if (!Array.isArray(data.allinventoryentries)) {
+        throw new Error("allinventoryentries must be an array");
+    }
+
+    if (data.allinventoryentries.length === 0) {
+        throw new Error("allinventoryentries cannot be empty");
+    }
+
+    // optional: validate one item structure
+    const item = data.allinventoryentries[0];
+    if (!item.ItemName || !item.Qty) {
+        throw new Error("Invalid inventory item structure");
+    }
+
+    // 🔹 customerDetails
+    if (!data.customerDetails || typeof data.customerDetails !== "object") {
+        throw new Error("customerDetails must be an object");
+    }
+
+    if (!data.customerDetails.LedgerName) {
+        throw new Error("LedgerName is required in customerDetails");
+    }
+
+    if (!data.customerDetails.InvoiceDate) {
+        throw new Error("InvoiceDate is required in customerDetails");
+    }
+};
+
+export { validateImportVoucherInput };

package/src/v3/core/impotToTally.js

@@ -0,0 +1,14 @@
+export async function sendToTally(data, url = "http://localhost:9000") {
+    const res = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "TallyRequest": "Import",
+            "Type": "Data",
+            "Id": "Vouchers"
+        },
+        body: JSON.stringify(data)
+    });
+
+    return res.json();
+};

package/src/v1/Import/ledgers.json

@@ -1,8 +0,0 @@
-{
-    "static_variables": [
-        {
-            "name": "svExportFormat",
-            "value": "jsonex"
-        }
-    ]
-}

package/src/v1/api/index.js

@@ -1,3 +0,0 @@
-// src/v1/api/index.js
-export { ledger } from "./ledger.js";
-export { stockItems } from "./stockitems.js";

package/src/v1/config/getSchema.js

@@ -1,20 +0,0 @@
-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/src/v1/engine/index.js

@@ -1,5 +0,0 @@
-export * as query from "./query/index.js";
-export * as mutate from "./mutate/index.js";
-export * as remove from "./remove/index.js";
-export * as filter from "./filter/index.js";
-export * as aggregate from "./aggregate/index.js";

package/src/v1/engine/mutate/delete/deleteBase.js

@@ -1,26 +0,0 @@
-import { getConfig } from "../../../../core/configStore.js";
-import { buildDataPath } from "../../../../utils/pathBuilder.js";
-import { readData } from "../../../helpers/file/read.js";
-import { writeData } from "../../../helpers/file/write.js";
-
-const deleteBase = ({ table, pk }) => {
-    const config = getConfig();
-    const path = buildDataPath(config, table);
-
-    const data = readData(path);
-
-    const index = data.findIndex(r => r.pk === pk);
-
-    if (index === -1) {
-        throw new Error(`Record with pk ${pk} not found`);
-    }
-
-    const deleted = data[index];
-    data.splice(index, 1);
-
-    writeData(path, data);
-
-    return deleted;
-};
-
-export default deleteBase;

package/src/v1/engine/mutate/delete/deleteWithChecks.js

@@ -1,14 +0,0 @@
-import deleteBase from "./deleteBase.js";
-import { getSchema } from "../../../config/getSchema.js";
-
-const deleteWithChecks = ({ table, pk }) => {
-    const schema = getSchema(table);
-
-    if (!pk) {
-        throw new Error("pk is required");
-    }
-
-    return deleteBase({ table, pk });
-};
-
-export default deleteWithChecks;

package/src/v1/engine/mutate/index.js

@@ -1,7 +0,0 @@
-export { default as insertAsIs } from "./insert/insertAsIs.js";
-export { default as insertFlat } from "./insert/insertFlat.js";
-export { default as insertGenPk } from "./insert/insertGenPk.js";
-export { default as insertWithChecks } from "./insert/insertWithChecks.js";
-
-export { default as deleteWithChecks } from "./delete/deleteWithChecks.js";
-export { default as updateWithChecks } from "./update/updateWithChecks.js";

package/src/v1/engine/mutate/insert/insertAsIs.js

@@ -1,7 +0,0 @@
-import insertBase from "./insertBase.js";
-
-const insertAsIs = ({ table, record }) => {
-    return insertBase({ table, record });
-};
-
-export default insertAsIs;

package/src/v1/engine/mutate/insert/insertBase.js

@@ -1,19 +0,0 @@
-import { getConfig } from "../../../../core/configStore.js";
-import { buildDataPath } from "../../../../utils/pathBuilder.js";
-import { readData } from "../../../helpers/file/read.js";
-import { writeData } from "../../../helpers/file/write.js";
-
-const insertBase = ({ table, record }) => {
-    const config = getConfig();
-    const path = buildDataPath(config, table);
-
-    const data = readData(path);
-
-    data.push(record);
-
-    writeData(path, data);
-
-    return record;
-};
-
-export default insertBase;

package/src/v1/engine/mutate/insert/insertFlat.js

@@ -1,24 +0,0 @@
-import insertBase from "./insertBase.js";
-
-const isPlainObject = (val) =>
-    typeof val === "object" && val !== null && !Array.isArray(val);
-
-const isPrimitive = (val) =>
-    val === null ||
-    ["string", "number", "boolean"].includes(typeof val);
-
-const insertFlat = ({ table, record }) => {
-    if (!isPlainObject(record)) {
-        throw new Error("must be object");
-    }
-
-    for (const key in record) {
-        if (!isPrimitive(record[key])) {
-            throw new Error(`invalid value for ${key}`);
-        }
-    }
-
-    return insertBase({ table, record });   // 🔥 reuse
-};
-
-export default insertFlat;

package/src/v1/engine/mutate/insert/insertGenPk copy.js

@@ -1,39 +0,0 @@
-import insertBase from "./insertBase.js";
-
-import { getConfig } from "../../../../core/configStore.js";
-import { buildDataPath } from "../../../../utils/pathBuilder.js";
-import { readData } from "../../../helpers/file/read.js";
-
-import { getSchema } from "../../../config/getSchema.js";
-import { getPrimaryKey, attachPrimaryKey } from "../../../helpers/pkHelper.js";
-
-const insertGenPk = ({ table, record }) => {
-    let schema;
-    try {
-        schema = getSchema(table);
-    } catch (err) {
-        console.error(err.message);
-        return; // or throw based on your design
-    };
-
-    // const schema = getSchema(table);
-    const pk = getPrimaryKey(schema.columns);
-
-    // ✅ if pk already exists, skip generation
-    if (record[pk] !== undefined) {
-        return insertBase({ table, record });
-    }
-
-    const config = getConfig();
-    const path = buildDataPath(config, table);
-    const data = readData(path);
-
-    const newRecord = attachPrimaryKey(record, pk, data);
-
-    return insertBase({
-        table,
-        record: newRecord
-    });
-};
-
-export default insertGenPk;

package/src/v1/engine/mutate/insert/insertGenPk.js

@@ -1,41 +0,0 @@
-import insertBase from "./insertBase.js";
-import { getConfig } from "../../../../core/configStore.js";
-import { buildDataPath } from "../../../../utils/pathBuilder.js";
-import { readData } from "../../../helpers/file/read.js";
-import { getSchema } from "../../../config/getSchema.js";
-import { getPrimaryKey, attachPrimaryKey } from "../../../helpers/pkHelper.js";
-
-const validateInput = ({ table, record }) => {
-    if (!table) throw new Error("table is required");
-    if (!record || typeof record !== "object") throw new Error("record must be object");
-};
-
-const safeGetSchema = (table) => {
-    const schema = getSchema(table);
-    if (!schema?.columns) throw new Error(`Invalid schema for "${table}"`);
-    return schema;
-};
-
-const getData = (table) => {
-    const config = getConfig();
-    const path = buildDataPath(config, table);
-    return readData(path);
-};
-
-const insertGenPk = ({ table, record }) => {
-    validateInput({ table, record });
-
-    const schema = safeGetSchema(table);
-    const pk = getPrimaryKey(schema.columns);
-
-    if (record[pk] !== undefined) {
-        return insertBase({ table, record });
-    }
-
-    const data = getData(table);
-    const newRecord = attachPrimaryKey(record, pk, data);
-
-    return insertBase({ table, record: newRecord });
-};
-
-export default insertGenPk;

package/src/v1/engine/mutate/insert/insertWithChecks.js

@@ -1,52 +0,0 @@
-import insertBase from "./insertBase.js";
-import validate from "../../../helpers/validate.js";
-
-import { getSchema } from "../../../config/getSchema.js";
-import { getPrimaryKey, attachPrimaryKey } from "../../../helpers/pkHelper.js";
-
-import { getConfig } from "../../../../core/configStore.js";
-import { buildDataPath } from "../../../../utils/pathBuilder.js";
-import { readData } from "../../../helpers/file/read.js";
-
-const insertWithChecks1 = ({ table, record }) => {
-    const schema = getSchema(table);
-
-    // 🔥 PK handling
-    const pk = getPrimaryKey(schema.columns);
-
-    if (record[pk] === undefined) {
-        const config = getConfig();
-        const path = buildDataPath(config, table);
-        const data = readData(path);
-
-        record = attachPrimaryKey(record, pk, data);
-    }
-
-    // 🔥 validate AFTER pk
-    validate(schema, record);
-
-    return insertBase({ table, record });
-};
-
-const insertWithChecks = ({ table, record }) => {
-    try {
-        const schema = getSchema(table);
-        const pk = getPrimaryKey(schema.columns);
-
-        if (record[pk] === undefined) {
-            const config = getConfig();
-            const path = buildDataPath(config, table);
-            const data = readData(path);
-            record = attachPrimaryKey(record, pk, data);
-        }
-
-        validate(schema, record);
-
-        return insertBase({ table, record });
-
-    } catch (err) {
-        throw new Error(`Insert failed [${table}]: ${err.message}`);
-    }
-};
-
-export default insertWithChecks;

package/src/v1/engine/mutate/update/updateBase.js

@@ -1,26 +0,0 @@
-import { getConfig } from "../../../../core/configStore.js";
-import { buildDataPath } from "../../../../utils/pathBuilder.js";
-import { readData } from "../../../helpers/file/read.js";
-import { writeData } from "../../../helpers/file/write.js";
-
-const updateBase = ({ table, pk, updates }) => {
-    const config = getConfig();
-    const path = buildDataPath(config, table);
-
-    const data = readData(path);
-
-    const index = data.findIndex(r => r.pk === pk);
-    if (index === -1) {
-        throw new Error(`Record with pk ${pk} not found`);
-    }
-
-    const existing = data[index];
-    const updated = { ...existing, ...updates, pk: existing.pk }; // 🔥 keep pk safe
-
-    data[index] = updated;
-    writeData(path, data);
-
-    return updated;
-};
-
-export default updateBase;

package/src/v1/engine/mutate/update/updateWithChecks.js

@@ -1,18 +0,0 @@
-import updateBase from "./updateBase.js";
-import validate from "../../../helpers/validate.js";
-import { getSchema } from "../../../config/getSchema.js";
-
-const updateWithChecks = ({ table, pk, record }) => {
-    if (!pk) throw new Error("pk is required");
-
-    const schema = getSchema(table);
-
-    // merge for validation
-    const merged = { ...record, pk };
-
-    validate(schema, merged); // 🔥 reuse same validator
-
-    return updateBase({ table, pk, updates: record });
-};
-
-export default updateWithChecks;

package/src/v1/engine/query/aggregate/count.js

@@ -1,13 +0,0 @@
-import { getConfig } from "../../../../core/configStore.js";
-import { buildDataPath } from "../../../../utils/pathBuilder.js";
-
-import { readData } from "../../../helpers/file/read.js";
-
-export default ({ table }) => {
-    const cfg = getConfig();
-    const path = buildDataPath(cfg, table);
-
-    const data = readData(path) || [];
-
-    return Array.isArray(data) ? data.length : 0;
-};

package/src/v1/engine/query/aggregate/index.js

@@ -1 +0,0 @@
-export { default as count } from "./count.js";

package/src/v1/engine/query/filterByColumns.js

@@ -1,18 +0,0 @@
-import { getConfig } from "../../../core/configStore.js";
-import { buildDataPath } from "../../../utils/pathBuilder.js";
-import { readData } from "../../helpers/file/read.js";
-
-const filterByColumns = ({ table, where = {} }) => {
-    const cfg = getConfig();
-    const path = buildDataPath(cfg, table);
-
-    const data = readData(path) || [];
-
-    return data.filter(row =>
-        Object.entries(where).every(([key, val]) =>
-            row[key] === val
-        )
-    );
-};
-
-export default filterByColumns;

package/src/v1/engine/query/filterByPk.js

@@ -1,18 +0,0 @@
-import { getConfig } from "../../../core/configStore.js";
-import { buildDataPath } from "../../../utils/pathBuilder.js";
-import { getPrimaryKey } from "../../helpers/pkHelper.js";
-import { getSchema } from "../../config/getSchema.js";
-import { readData } from "../../helpers/file/read.js";
-
-const filterByPk = ({ table, id }) => {
-  const cfg = getConfig();
-  const schema = getSchema(table);
-  const pk = getPrimaryKey(schema.columns);
-
-  const path = buildDataPath(cfg, table);
-  const data = readData(path);
-
-  return data.filter(row => Number(row[pk]) === Number(id)) || [];
-};
-
-export default filterByPk;

package/src/v1/engine/query/findAll.js

@@ -1,14 +0,0 @@
-import { getConfig } from "../../../core/configStore.js";
-import { buildDataPath } from "../../../utils/pathBuilder.js";
-import { readData } from "../../helpers/file/read.js";
-
-const findAll = ({ table }) => {
-  const config = getConfig();
-  const path = buildDataPath(config, table);
-
-  const data = readData(path);
-
-  return data;
-};
-
-export default findAll;

package/src/v1/engine/query/findByPk.js

@@ -1,18 +0,0 @@
-import { getConfig } from "../../../core/configStore.js";
-import { buildDataPath } from "../../../utils/pathBuilder.js";
-import { getPrimaryKey } from "../../helpers/pkHelper.js";
-import { getSchema } from "../../config/getSchema.js";
-import { readData } from "../../helpers/file/read.js";
-
-const findByPk = ({ table, id }) => {
-  const cfg = getConfig();
-  const schema = getSchema(table);
-  const pk = getPrimaryKey(schema.columns);
-
-  const path = buildDataPath(cfg, table);
-  const data = readData(path);
-
-  return data.find(row => Number(row[pk]) === Number(id)) || null;
-};
-
-export default findByPk;

package/src/v1/engine/query/index.js

@@ -1,8 +0,0 @@
-import * as aggregate from "./aggregate/index.js";
-
-export { default as findAll } from "./findAll.js";
-export { default as findByPk } from "./findByPk.js";
-export { default as filterByPk } from "./filterByPk.js";
-export { default as filterByColumns } from "./filterByColumns.js";
-
-export { aggregate };

package/src/v1/helpers/buildMutate.js

@@ -1,28 +0,0 @@
-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 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),
-    updateWithChecks: updateWithChecks(mutate, tableName)
-});
-
-export default buildMutate;

package/src/v1/helpers/buildQuery.js

@@ -1,27 +0,0 @@
-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 })
-    }
-});
-
-export default buildQuery;

package/src/v1/helpers/file/read.js

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

package/src/v1/helpers/file/write.js

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

package/src/v1/helpers/pkHelper.js

@@ -1,19 +0,0 @@
-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/src/v1/helpers/validate.js

@@ -1,27 +0,0 @@
-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/src/v1/helpers/validateHelper.js

@@ -1,27 +0,0 @@
-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/src/v1/helpers/validators/default.js

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

package/src/v1/helpers/validators/enum.js

@@ -1,7 +0,0 @@
-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/src/v1/helpers/validators/length.js

@@ -1,11 +0,0 @@
-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/src/v1/helpers/validators/minMax.js

@@ -1,11 +0,0 @@
-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/src/v1/helpers/validators/pattern.js

@@ -1,8 +0,0 @@
-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/src/v1/helpers/validators/required.js

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

package/src/v1/helpers/validators/type.js

@@ -1,15 +0,0 @@
-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/src/v1/helpers/validators/unique.js

@@ -1,8 +0,0 @@
-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/src/v1/schema/schema.json

@@ -1,133 +0,0 @@
-{
-    "query": {
-        "findAll": {
-            "args": [],
-            "desc": "Retrieve all rows from the table",
-            "example": [
-                "",
-                "const tableData = table.query.findAll();",
-                "",
-                "console.log('Table Data:', tableData);"
-            ]
-        },
-        "findByPk": {
-            "args": [
-                "pk"
-            ],
-            "desc": "Retrieve a single row by primary key",
-            "example": [
-                "const table = kschema.table('LedgerNames');",
-                "const row = table.query.findByPk(1);",
-                "console.log('Row by PK:', row);"
-            ]
-        },
-        "filterByPk": {
-            "args": [
-                "pk"
-            ],
-            "desc": "Filter rows matching primary key",
-            "example": [
-                "const table = kschema.table('LedgerNames');",
-                "const rows = table.query.filterByPk(1);",
-                "console.log('Filtered Rows (PK):', rows);"
-            ]
-        },
-        "filterByColumns": {
-            "args": [
-                "where"
-            ],
-            "desc": "Filter rows using column conditions",
-            "example": [
-                "const table = kschema.table('LedgerNames');",
-                "const rows = table.query.filterByColumns({ name: 'Cash' });",
-                "console.log('Filtered Rows (Columns):', rows);"
-            ]
-        },
-        "aggregate": {
-            "count": {
-                "args": [
-                    "column?"
-                ],
-                "desc": "Count rows or values of a column",
-                "example": [
-                    "const table = kschema.table('LedgerNames');",
-                    "const total = table.query.aggregate.count();",
-                    "console.log('Total Rows Count:', total);"
-                ]
-            }
-        }
-    },
-    "mutate": {
-        "insertAsIs": {
-            "args": [
-                "record"
-            ],
-            "desc": "Insert record without modification",
-            "example": [
-                "const insertedRow = table.mutate.insertAsIs({ LedgerName: 'KeshavSoft' });",
-                "",
-                "console.log('Inserted record as insertAsIs : ', insertedRow);"
-            ]
-        },
-        "insertFlat": {
-            "args": [
-                "record"
-            ],
-            "desc": "Insert flattened record",
-            "example": [
-                "const table = kschema.table('LedgerNames');",
-                "table.mutate.insertFlat({ name: 'Bank' });",
-                "console.log('Inserted flat record');"
-            ]
-        },
-        "insertGenPk": {
-            "args": [
-                "record"
-            ],
-            "desc": "Insert record with auto-generated primary key",
-            "example": [
-                "const insertedRow = table.mutate.insertGenPk({ LedgerName: 'KeshavSoft' });",
-                "",
-                "console.log('Inserted record as insertGenPk : ', insertedRow);"
-            ]
-        },
-        "insertWithChecks": {
-            "args": [
-                "record"
-            ],
-            "desc": "Insert record with validation checks",
-            "example": [
-                "try {",
-                "\tconst fromInserted = table.mutate.insertWithChecks({ LedgerName: 'Keshav' });",
-                "",
-                "\tconsole.log('fromInserted : ', fromInserted);",
-                "} catch (err) {",
-                "\tconsole.log(err.message);",
-                "};"
-            ]
-        },
-        "deleteWithChecks": {
-            "args": [
-                "pk"
-            ],
-            "desc": "Delete record by primary key with validation",
-            "example": [
-                "const table = kschema.table('LedgerNames');",
-                "table.mutate.deleteWithChecks(1);",
-                "console.log('Deleted record with checks');"
-            ]
-        },
-        "updateWithChecks": {
-            "args": [
-                "pk",
-                "record"
-            ],
-            "desc": "Update record by primary key with validation",
-            "example": [
-                "const table = kschema.table('LedgerNames');",
-                "table.mutate.updateWithChecks(1, { name: 'Updated Ledger' });",
-                "console.log('Updated record with checks');"
-            ]
-        }
-    }
-}