tally-simple 1.1.1 → 1.8.2

package/src/v7/internal-working/execution/index.js

@@ -0,0 +1,30 @@
+import validateCompany from "./validateCompany.js";
+import getTdl from "./getTdl.js";
+import buildXmlBody from "./buildXmlBody.js";
+import postHttp from "./postHttp.js";
+
+const startFunc = async ({ inRoutePath, inCompany, inSource }) => {
+    const localRoutePath = inRoutePath;
+    const localCompany = inCompany;
+    const localSource = inSource;
+
+    const companyName = validateCompany({
+        inCompany: localCompany
+    });
+
+    const tdl = getTdl({
+        inSource: localSource,
+        inRoutePath: localRoutePath
+    });
+
+    const xmlBody = buildXmlBody({
+        inCompany: companyName,
+        inTdl: tdl
+    });
+
+    return await postHttp({
+        inXmlBody: xmlBody
+    });
+};
+
+export default startFunc;

package/src/v7/internal-working/execution/postHttp.js

@@ -0,0 +1,26 @@
+const url = "http://localhost:9000";
+const headers = {
+    "Content-Type": "text/xml"
+};
+
+const startFunc = async ({ inXmlBody }) => {
+    const localXmlBody = inXmlBody;
+
+    const response = await fetch(url, {
+        method: "POST",
+        headers: headers,
+        body: localXmlBody
+    });
+
+    const responseText = await response.text();
+
+    if (!response.ok) {
+        throw new Error(
+            `Tally request failed with HTTP ${response.status}: ${responseText}`
+        );
+    }
+
+    return responseText;
+};
+
+export default startFunc;

package/src/v7/internal-working/execution/validateCompany.js

@@ -0,0 +1,11 @@
+const startFunc = ({ inCompany }) => {
+    const localCompany = inCompany;
+
+    if (typeof localCompany !== "string" || !localCompany.trim()) {
+        throw new TypeError("Company name is required.");
+    }
+
+    return localCompany.trim();
+};
+
+export default startFunc;

package/src/v7/internal-working/route/attachPath.js

@@ -0,0 +1,25 @@
+import createLeafHandler from "./createLeafHandler.js";
+
+const startFunc = ({ inTree, inPath, inSource, inExecutor }) => {
+    const localTree = inTree;
+    const localPath = inPath;
+    const localSource = inSource;
+    const localExecutor = inExecutor;
+
+    const parts = localPath.split(".");
+    const leafName = parts.pop();
+
+    let branch = localTree;
+    for (const segment of parts) {
+        branch[segment] ??= {};
+        branch = branch[segment];
+    }
+
+    branch[leafName] = createLeafHandler({
+        inPath: localPath,
+        inSource: localSource,
+        inExecutor: localExecutor
+    });
+};
+
+export default startFunc;

package/src/v7/internal-working/route/createLeafHandler.js

@@ -0,0 +1,17 @@
+const startFunc = ({ inPath, inSource, inExecutor }) => {
+    const localPath = inPath;
+    const localSource = inSource;
+    const localExecutor = inExecutor;
+
+    return async (inCompany) => {
+        const localCompany = inCompany;
+
+        return await localExecutor({
+            inRoutePath: localPath,
+            inCompany: localCompany,
+            inSource: localSource
+        });
+    };
+};
+
+export default startFunc;

package/src/v7/internal-working/route/index.js

@@ -0,0 +1,24 @@
+import attachPath from "./attachPath.js";
+
+const startFunc = ({ inApiPaths, inSource, inExecutor }) => {
+    const localApiPaths = inApiPaths;
+    const localSource = inSource;
+    const localExecutor = inExecutor;
+
+    const tree = {};
+
+    for (const path of localApiPaths) {
+        attachPath({
+            inTree: tree,
+            inPath: path,
+            inSource: localSource,
+            inExecutor: localExecutor
+        });
+    }
+
+    const rootNamespace = localApiPaths[0]?.split(".")[0];
+
+    return rootNamespace ? tree[rootNamespace] : tree;
+};
+
+export default startFunc;

package/src/v7/source.json

@@ -0,0 +1,38 @@
+{
+    "tally": {
+        "masters": {
+            "units": {
+                "fetch": {
+                    "tdl": {
+                        "collection": "<TYPE>Unit</TYPE>\n<FETCH>$$Alias:Name</FETCH>\n"
+                    },
+                    "action": "fetch"
+                }
+            },
+            "stockItems": {
+                "withBatches": {
+                    "tdl": {
+                        "collection": "<TYPE>StockItem</TYPE><FETCH>$$Alias:Name</FETCH><FETCH>BaseUnits</FETCH><FETCH>BatchAllocations.*</FETCH>"
+                    },
+                    "action": "fetch"
+                }
+            },
+            "ledgers": {
+                "withGstDetails": {
+                    "tdl": {
+                        "collection": "<TYPE>Ledger</TYPE><FETCH>$$Alias:Name</FETCH><FETCH>LEDGSTREGDETAILS.LIST</FETCH>"
+                    },
+                    "action": "fetch"
+                }
+            },
+            "stockGroup": {
+                "withParent": {
+                    "tdl": {
+                        "collection": "<TYPE>StockGroup</TYPE><FETCH>$$Alias:Name</FETCH><FETCH>Parent</FETCH>"
+                    },
+                    "action": "fetch"
+                }
+            }
+        }
+    }
+}

package/src/v8/engine/index.js

@@ -0,0 +1,18 @@
+import { call } from "tally-simple-json";
+import transform from "@keshavsoft/json-transformer";
+
+const startFunc = async ({ inRoutePath, inParam, inSource, inLeafSpec }) => {
+    const localRoutePath = inRoutePath;
+    const localParam = inParam;
+    const localSource = inSource;
+    const localLeafSpec = inLeafSpec;
+
+    const rawResponse = await call(localRoutePath,
+        localParam);
+    const jsonNeeded = rawResponse?.ENVELOPE?.BODY?.DATA?.COLLECTION;
+    const transformedResponse = transform(jsonNeeded, localLeafSpec?.transform?.instructions);
+    // console.log("localSource: ", jsonNeeded, localLeafSpec?.transform?.instructions, transformedResponse);
+    return transformedResponse;
+};
+
+export default startFunc;

package/src/v8/engine/parseXml.js

@@ -0,0 +1,11 @@
+import { XMLParser } from "fast-xml-parser";
+
+const parser = new XMLParser({ ignoreAttributes: false });
+
+const startFunc = ({ inXml }) => {
+    const localXml = inXml;
+
+    return parser.parse(localXml);
+};
+
+export default startFunc;

package/src/v8/index.js

@@ -0,0 +1,21 @@
+import apiTree, { createCaller } from "@keshavsoft/api-tree";
+import { source, apiPaths } from "tally-spec";
+
+import execute from "./engine/index.js";
+
+const tree = apiTree(source, apiPaths, execute);
+const app = tree.tally ?? tree;
+
+// Keep the package's historical root API while retaining the explicit
+// `app.tally` form exposed by @keshavsoft/api-tree.
+if (!app.tally) {
+    Object.defineProperty(app, "tally", {
+        value: app,
+        enumerable: false
+    });
+};
+
+const call = createCaller({ inSource: source, inExecutor: execute });
+
+export default app;
+export { app, call };

package/docs/api.md

@@ -1,19 +0,0 @@
-# Published API paths
-
-These are the paths intentionally exposed by the package. The root tally is present on the default JavaScript import, while the CLI accepts paths with or without that root.
-
-| JavaScript call | CLI path | TDL request |
-| --- | --- | --- |
-| tally.masters.units.fetch(company) | masters.units.fetch | Unit with $$Alias:Name |
-| tally.masters.stockItems.withBatches(company) | masters.stockItems.withBatches | StockItem with base units and batch allocations |
-| tally.masters.ledgers.withGstDetails(company) | masters.ledgers.withGstDetails | Ledger with GST registration details |
-
-All current calls:
-
-- accept one company name;
-- make a POST request with XML;
-- return Tally's response body as a string;
-- use the configured endpoint and headers;
-- reject blank company names.
-
-The source of truth for the request definitions is src/v1/source.json. The allowlist for this published surface is src/v1/external-api/api.json.

package/docs/cli.md

@@ -1,32 +0,0 @@
-# CLI reference
-
-The package publishes the tally-simple executable. With npm, use it through npx:
-
-~~~bash
-npx tally-simple <api-path> --company <company>
-~~~
-
-## Options
-
-| Option | Meaning |
-| --- | --- |
-| -c, --company <name> | Company to query. Also reads TALLY_COMPANY. |
-| -u, --url <url> | Tally endpoint. Also reads TALLY_URL. |
-| --header <name:value> | Adds a request header. Repeat it for multiple headers. |
-| --timeout <ms> | Aborts a request after the given number of milliseconds. |
-| -h, --help | Prints command help. |
-| -v, --version | Prints the installed package version. |
-
-The command accepts masters.units.fetch and tally.masters.units.fetch equivalently. The response is written unchanged to stdout; errors and usage help are written to stderr.
-
-Examples:
-
-~~~bash
-npx tally-simple masters.units.fetch --company Mani9
-
-npx tally-simple masters.stockItems.withBatches \
-    --company Mani9 \
-    --header X-Request-Source:nightly
-
-TALLY_COMPANY=Mani9 npx tally-simple masters.units.fetch
-~~~

package/docs/development.md

@@ -1,66 +0,0 @@
-# Developer guide
-
-This document explains how Tally Simple is built and how to change it. End-user installation and query examples are kept in the root README.
-
-## The developer story
-
-Tally Simple keeps the TDL request definitions in one internal source and exposes only the queries deliberately selected for users.
-
-~~~text
-source.json
-    │
-    ├── public API list ──> JavaScript client
-    │
-    └── request traversal ──> XML over HTTP ──> Tally
-                         │
-                         └──> CLI stdout
-~~~
-
-The source definitions describe how Tally should answer a query. The public API list is the product boundary: only listed paths become JavaScript methods and CLI commands.
-
-## Repository map
-
-- src/v1/source.json: Tally connection defaults, request envelope, and TDL collections.
-- src/v1/external-api/api.json: public query allowlist.
-- src/v1/external-api/api.js: builds the nested runtime API.
-- src/v1/traverse.js: validates, builds, and sends a request.
-- src/index.d.ts: generated TypeScript declarations.
-- bin/tally-simple.js: command-line entrypoint.
-- test/test.js and test/units.js: offline behavior and CLI tests.
-- test/v1/units.js: manual integration smoke check against a reachable Tally instance; it is not part of npm test.
-
-## Request lifecycle
-
-1. The application or CLI selects a public query path.
-2. The client validates and trims the company name.
-3. The path is resolved in source.json.
-4. The company name is XML-escaped and inserted into the request envelope.
-5. The selected collection body is inserted into the envelope.
-6. The configured fetch implementation sends the request to Tally.
-7. The response body is returned as text; non-2xx responses become errors.
-
-## Adding a query
-
-1. Add or update the TDL definition in src/v1/source.json.
-2. Add its complete path to src/v1/external-api/api.json.
-3. Run npm run generate:dts.
-4. Add or update an offline test.
-5. Run npm run verify.
-
-Do not edit src/index.d.ts by hand. It is generated from the source definition and public path list.
-
-## Client configuration
-
-createTallyClient() is the application boundary for a different URL, method, headers, timeout, or fetch implementation. The default import uses the default connection from source.json.
-
-The fetch option is intentionally injectable so tests can run without a Tally installation or network connection.
-
-## Verification and publishing
-
-~~~bash
-npm install
-npm run verify
-npm pack --dry-run
-~~~
-
-The prepack and prepublishOnly hooks run declaration generation and the offline test suite. The package files allowlist publishes the runtime, CLI, user documentation, and package metadata while excluding tests and development-only scripts.

package/src/index.d.ts

@@ -1,36 +0,0 @@
-export interface TallyClientOptions {
-    url?: string;
-    method?: string;
-    headers?: Record<string, string>;
-    timeout?: number;
-    fetch?: (url: string, options: {
-        method: string;
-        headers: Record<string, string>;
-        body: string;
-        signal?: unknown;
-    }) => Promise<{
-        ok: boolean;
-        status: number;
-        text: () => Promise<string>;
-    }>;
-}
-
-export type TallyApi = {
-    masters: {
-        units: {
-            fetch: (company: string) => Promise<string>;
-        };
-        stockItems: {
-            withBatches: (company: string) => Promise<string>;
-        };
-        ledgers: {
-            withGstDetails: (company: string) => Promise<string>;
-        };
-    };
-};
-
-declare const tally: TallyApi;
-
-export declare const createTallyClient: (options?: TallyClientOptions) => TallyApi;
-export declare const tally: TallyApi;
-export default tally;

package/src/v1/external-api/api.js

@@ -1,67 +0,0 @@
-import source from "../source.json" with { type: "json" };
-import traverse from "../traverse.js";
-import apiPaths from "./api.json" with { type: "json" };
-
-const createApi = (options = {}) => {
-    const connection = {
-        ...source.tally.connection,
-        ...options.connection,
-        ...(options.url ? { url: options.url } : {}),
-        ...(options.method ? { method: options.method } : {}),
-        headers: {
-            ...source.tally.connection.headers,
-            ...options.connection?.headers,
-            ...options.headers
-        }
-    };
-    const request = options.request ?? source.tally.request;
-    const fetchImpl = options.fetch ?? globalThis.fetch;
-    const clientSource = {
-        ...source,
-        tally: {
-            ...source.tally,
-            connection,
-            request
-        }
-    };
-
-    const createFunction = (path) => async (company) => {
-        if (typeof company !== "string" || !company.trim()) {
-            throw new TypeError("Company name is required.");
-        }
-
-        return await traverse(clientSource, "", path, {
-            company: company.trim(),
-            connection,
-            request,
-            fetch: fetchImpl,
-            timeout: options.timeout
-        });
-    };
-
-    const root = {};
-
-    for (const path of apiPaths) {
-        const parts = path.split(".");
-        let current = root;
-
-        parts.forEach((part, index) => {
-            const isLast = index === parts.length - 1;
-
-            if (isLast) {
-                current[part] = createFunction(path);
-                return;
-            }
-
-            current[part] ??= {};
-            current = current[part];
-        });
-    }
-
-    const rootName = apiPaths[0]?.split(".")[0];
-
-    return rootName ? root[rootName] : root;
-};
-
-export { createApi };
-export default createApi();

package/src/v1/external-api/api.json

@@ -1,5 +0,0 @@
-[
-  "tally.masters.units.fetch",
-  "tally.masters.stockItems.withBatches",
-  "tally.masters.ledgers.withGstDetails"
-]

package/src/v1/external-api/index.js

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

package/src/v1/index.js

@@ -1 +0,0 @@
-export { createApi, default } from "./external-api/api.js";

package/src/v1/traverse.js

@@ -1,103 +0,0 @@
-import traverseObject from "./traverseObject/index.js";
-
-const escapeXml = (value) => value.replace(/[&<>"']/g, (character) => ({
-    "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&apos;"
-}[character]));
-
-const buildRequestBody = (requestBody, { company, collection }) => {
-    return requestBody
-        .replace("{company}", escapeXml(company))
-        .replace("{collectionBody}", collection);
-};
-
-const execute = async (connection, xml, fetchImpl, timeout) => {
-    if (typeof fetchImpl !== "function") {
-        throw new Error(
-            "No fetch implementation is available. Use Node.js 20+ or provide fetch to createTallyClient()."
-        );
-    }
-
-    const controller = typeof AbortController === "function"
-        ? new AbortController()
-        : undefined;
-    const timeoutId = Number.isFinite(timeout) && timeout > 0
-        ? setTimeout(() => controller?.abort(), timeout)
-        : undefined;
-
-    let response;
-
-    try {
-        response = await fetchImpl(connection.url, {
-            method: connection.method,
-            headers: connection.headers,
-            body: xml,
-            ...(controller ? { signal: controller.signal } : {})
-        });
-    } catch (error) {
-        if (controller?.signal.aborted) {
-            throw new Error(`Tally request timed out after ${timeout} ms.`, {
-                cause: error
-            });
-        }
-
-        throw error;
-    } finally {
-        if (timeoutId) clearTimeout(timeoutId);
-    }
-
-    const responseText = await response.text();
-
-    if (!response.ok) {
-        throw new Error(
-            `Tally request failed with HTTP ${response.status}: ${responseText}`
-        );
-    }
-
-    return responseText;
-};
-
-const traverse = async (
-    raka,
-    relativePath,
-    pathToFind,
-    context = {}
-) => {
-    if (relativePath === pathToFind) {
-        if (raka?.action === "fetch") {
-            const body = buildRequestBody(
-                context.request.body,
-                {
-                    company: context.company,
-                    collection: raka.tdl.collection
-                }
-            );
-
-            return await execute(
-                context.connection,
-                body,
-                context.fetch,
-                context.timeout
-            );
-        }
-
-        return raka;
-    }
-
-    if (typeof raka === "object" && raka !== null) {
-        return await traverseObject(
-            raka,
-            relativePath,
-            pathToFind,
-            context
-        );
-    }
-
-    return undefined;
-};
-
-export { traverse };
-export default traverse;

package/src/v1/traverseObject/index.js

@@ -1,39 +0,0 @@
-import { traverse } from "../traverse.js";
-
-const traverseObject = async (
-    specJson,
-    relativePath,
-    pathToFind,
-    context = {}
-) => {
-    const nextContext = {
-        ...context,
-        connection: specJson.connection ?? context.connection,
-        request: specJson.request ?? context.request
-    };
-
-    for (const [key, value] of Object.entries(specJson)) {
-        if (key === "connection" || key === "request") continue;
-
-        if (typeof value === "object" && value !== null) {
-            const nextPath = relativePath
-                ? `${relativePath}.${key}`
-                : key;
-
-            const result = await traverse(
-                value,
-                nextPath,
-                pathToFind,
-                nextContext
-            );
-
-            if (result !== undefined) {
-                return result;
-            }
-        }
-    }
-
-    return undefined;
-};
-
-export default traverseObject;