@keshavsoft/tallyextract 1.1.2

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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,13 @@
+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

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

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/v1/index.js

@@ -0,0 +1 @@
+export * from "./api/index.js";

package/src/v1/schema/schema.json

@@ -0,0 +1,133 @@
+{
+    "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');"
+            ]
+        }
+    }
+}

package/src/v1/utils/readJson.js

@@ -0,0 +1,6 @@
+// utils/readJson.js
+import fs from "fs/promises";
+
+export async function readJson(filePath) {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+};