@ekwo-ai/core 0.4.0

package/README.md

@@ -0,0 +1,76 @@
+# @ekwo-ai/core
+
+TypeScript row types and a typed client for the
+[Ekwo OS](https://github.com/Ekwo-ai/ekwo-os) accounting schema.
+
+- **Types of the whole schema**, hand written so they stay readable: accounts,
+  journals, entries and lines, documents and lines, taxes and tax postings,
+  and the row shapes the report functions return.
+- **The French FEC lives in [`@ekwo-ai/fec`](../formats/fec/)**, which is MIT
+  and depends on nothing. It is no longer re-exported here: import it from
+  there.
+- **A thin client** over the functions that carry the accounting rules —
+  `post_document`, `reconcile`, `trial_balance`, `vat_return`, `fec_lines`.
+  Everything else is a table, and Supabase already exposes those as REST.
+- **No runtime dependency of its own.** `@supabase/supabase-js` is an optional
+  peer; `@ekwo-ai/fec` is there because `generateFec()` on the client writes
+  the file it has just fetched.
+
+## Install
+
+```sh
+npm install @ekwo-ai/core
+```
+
+## Usage
+
+```ts
+import { EkwoClient } from '@ekwo-ai/core';
+import { fecFileName } from '@ekwo-ai/fec';
+import { createClient } from '@supabase/supabase-js';
+
+const ekwo = new EkwoClient(createClient(url, key));
+
+const entry = await ekwo.postDocument(documentId);
+await ekwo.reconcile(receivableLineId, bankLineId);
+
+const balance = await ekwo.trialBalance({ companyId, from: '2026-01-01', to: '2026-12-31' });
+const boxes   = await ekwo.vatReturn({ companyId, from: '2026-07-01', to: '2026-09-30' });
+const aged    = await ekwo.agedBalance(companyId, '2026-09-30', 'receivable');
+
+const fec = await ekwo.generateFec({ companyId, from: '2026-01-01', to: '2026-12-31' });
+await writeFile(fecFileName('123456789', '2026-12-31'), fec, 'utf8');
+```
+
+Without a Supabase client, format the file yourself from the rows of
+`fec_lines()`:
+
+```ts
+import { checkFec, fromQueryRow, generateFec } from '@ekwo-ai/fec';
+
+const lines = rows.map(fromQueryRow);
+const violations = checkFec(lines);   // [] when the file is clean
+const file = generateFec(lines, { decimalSeparator: ',', fieldSeparator: '|' });
+```
+
+## API
+
+| Export | Description |
+|---|---|
+| `EkwoClient` | Wrapper over the accounting functions of the schema. |
+| `initInstance`, `claimInstanceAdmin` | Record the installation and take the first administrator seat. |
+| `registerInstance`, `unregisterInstance` | Opt into being reachable by Ekwo, and out again. Never required. |
+| `ACCOUNT_TYPES`, `internalGroup(type)` | The eighteen account types and their balance-sheet group. |
+| `isRegistered(instance)` | Whether the operator opted into registering with Ekwo. |
+| `isSale`, `isCreditNote`, `isAccountable` | Document type predicates. |
+| `createContact`, `createDocument`, `addDocumentLine`, `updateDocumentLines`, `postDocument`, `recordPayment`, `reconcile`, `settleFromStatement`, `listDocuments`, `getDocument`, … | Keeping the books, once for every surface: the functions the MCP server and the `ekwo` command line both call. Each takes a `Backend` — five operations, `select` `insert` `update` `remove` `rpc` — that the caller implements over whatever reaches the database as a user. No accounting rule is in them; the schema holds those. |
+| `BooksError`, `isRefusalState`, `socleCode`, `isServiceRoleKey` | What an error of that layer looks like, what counts as the database refusing, and the one key no surface accepts. |
+| Types | `Instance`, `InstanceAdmin`, `MemberRole`, `CompanyRole`, `Account`, `Journal`, `Entry`, `EntryLine`, `EkwoDocument`, `DocumentLine`, `Tax`, `TaxPosting`, `Contact`, `TrialBalanceRow`, `AgedBalanceRow`, `VatReturnRow`, … |
+
+Amounts come back from Postgres as strings, and the types say so: `numeric`
+is carried as `Decimal = string` rather than rounded into a float on the way
+in.
+
+## Licence
+
+[AGPL-3.0-only](../../LICENSE) © Ekwo AI.

package/dist/books/backend.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The one interface every bookkeeping function is written against.
+ *
+ * There are two ways to reach an Ekwo database and neither of them is a
+ * privileged one. The recommended route is PostgREST with the signed-in
+ * user's own token, which is how the schema is meant to be read and written:
+ * row level security decides, exactly as it would for that person in a
+ * browser. The second is a direct Postgres connection, for a self-hosted
+ * installation and for the tests — and even there the claims and the role are
+ * set on every call, so the same policies apply.
+ *
+ * The functions of this folder therefore never see a client, a token or a
+ * connection string. They see `select`, `insert`, `update`, `remove` and
+ * `rpc`, and what comes back is whatever the policies let through.
+ *
+ * This lived in the MCP server. The command line keeps the same books through
+ * the same functions, so the interface and the functions moved here, and each
+ * surface brings its own implementation of it: the server's over
+ * `@supabase/supabase-js` or a Postgres driver, the command line's over
+ * `fetch`. Nothing in this folder imports anything from outside the core.
+ */
+export type Value = string | number | boolean | null;
+export type Filter = {
+    column: string;
+    op: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte';
+    value: Value;
+} | {
+    column: string;
+    op: 'in';
+    value: Value[];
+} | {
+    column: string;
+    op: 'ilike';
+    value: string;
+} | {
+    column: string;
+    op: 'is';
+    value: null;
+};
+export interface Order {
+    column: string;
+    ascending?: boolean;
+}
+export interface SelectQuery {
+    table: string;
+    /**
+     * The Postgres schema the table lives in. Undefined is `public`, which is
+     * the socle; a module names its own — `assets`, `budgets` — and PostgREST
+     * serves it only once the project lists it under its exposed schemas.
+     */
+    schema?: string;
+    /**
+     * Columns to read. A `numeric` column is asked for as `amount::text`, so it
+     * arrives as the decimal string Postgres holds rather than as a float that
+     * JSON happened to survive. Both backends understand that spelling.
+     */
+    columns: string[];
+    where?: Filter[];
+    order?: Order[];
+    limit?: number;
+}
+export type Row = Record<string, unknown>;
+export interface Backend {
+    /** Which route this is, for `status` and for the error messages. */
+    readonly mode: 'postgrest' | 'sql';
+    /** Who we are acting as, when that is known. */
+    readonly actingAs: string | undefined;
+    /**
+     * Calls a function of the schema. Always an array of rows, whatever the
+     * function returns: PostgREST hands back an object for a function returning
+     * one composite row and an array for a set, and a tool should not have to
+     * care which route it came over.
+     */
+    rpc<T = Row>(fn: string, args?: Record<string, unknown>, schema?: string): Promise<T[]>;
+    /** The same, for a function that returns nothing. */
+    rpcVoid(fn: string, args?: Record<string, unknown>, schema?: string): Promise<void>;
+    select<T = Row>(query: SelectQuery): Promise<T[]>;
+    insert<T = Row>(table: string, rows: Row[], returning?: string[], schema?: string): Promise<T[]>;
+    update<T = Row>(table: string, patch: Row, where: Filter[], returning?: string[], schema?: string): Promise<T[]>;
+    remove(table: string, where: Filter[], schema?: string): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * An error of this layer, or one that carries what the database said.
+ *
+ * The accounting rules live in the schema and they raise with a prefixed code
+ * — `period_locked:`, `entry_unbalanced:`, `document_total_mismatch:`. Those
+ * messages are the most useful thing we can hand a model, so they travel up
+ * unchanged; `hint` adds the sentence a human would add, never a replacement.
+ */
+export declare class BooksError extends Error {
+    name: string;
+    readonly code: string | undefined;
+    readonly hint: string | undefined;
+    constructor(message: string, options?: {
+        code?: string | undefined;
+        hint?: string;
+    });
+}
+/**
+ * Refuses anything that is not a plain lowercase identifier.
+ *
+ * Table and column names in this package are written in this package — none
+ * of them comes from a tool argument. This function is the proof of that
+ * rather than a defence against it, and it costs nothing to keep true.
+ */
+/**
+ * `assets.assets`, or `assets` when there is no schema to name.
+ *
+ * Both halves go through `identifier()`, so a module code that came from the
+ * registry rather than from this package still cannot be anything but a plain
+ * lowercase name.
+ */
+export declare function qualified(schema: string | undefined, name: string): string;
+export declare function identifier(name: string): string;
+/** `amount::text` reads back as `amount`; every other column is itself. */
+export declare function columnName(column: string): string;
+//# sourceMappingURL=backend.d.ts.map

package/dist/books/backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../src/books/backend.ts"],"names":[],"mappings":"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"}

package/dist/books/backend.js

@@ -0,0 +1,69 @@
+/**
+ * The one interface every bookkeeping function is written against.
+ *
+ * There are two ways to reach an Ekwo database and neither of them is a
+ * privileged one. The recommended route is PostgREST with the signed-in
+ * user's own token, which is how the schema is meant to be read and written:
+ * row level security decides, exactly as it would for that person in a
+ * browser. The second is a direct Postgres connection, for a self-hosted
+ * installation and for the tests — and even there the claims and the role are
+ * set on every call, so the same policies apply.
+ *
+ * The functions of this folder therefore never see a client, a token or a
+ * connection string. They see `select`, `insert`, `update`, `remove` and
+ * `rpc`, and what comes back is whatever the policies let through.
+ *
+ * This lived in the MCP server. The command line keeps the same books through
+ * the same functions, so the interface and the functions moved here, and each
+ * surface brings its own implementation of it: the server's over
+ * `@supabase/supabase-js` or a Postgres driver, the command line's over
+ * `fetch`. Nothing in this folder imports anything from outside the core.
+ */
+/**
+ * An error of this layer, or one that carries what the database said.
+ *
+ * The accounting rules live in the schema and they raise with a prefixed code
+ * — `period_locked:`, `entry_unbalanced:`, `document_total_mismatch:`. Those
+ * messages are the most useful thing we can hand a model, so they travel up
+ * unchanged; `hint` adds the sentence a human would add, never a replacement.
+ */
+export class BooksError extends Error {
+    name = 'BooksError';
+    code;
+    hint;
+    constructor(message, options = {}) {
+        super(message);
+        this.code = options.code;
+        this.hint = options.hint;
+    }
+}
+const IDENTIFIER = /^[a-z_][a-z0-9_]*$/;
+/**
+ * Refuses anything that is not a plain lowercase identifier.
+ *
+ * Table and column names in this package are written in this package — none
+ * of them comes from a tool argument. This function is the proof of that
+ * rather than a defence against it, and it costs nothing to keep true.
+ */
+/**
+ * `assets.assets`, or `assets` when there is no schema to name.
+ *
+ * Both halves go through `identifier()`, so a module code that came from the
+ * registry rather than from this package still cannot be anything but a plain
+ * lowercase name.
+ */
+export function qualified(schema, name) {
+    return schema === undefined ? identifier(name) : `${identifier(schema)}.${identifier(name)}`;
+}
+export function identifier(name) {
+    if (!IDENTIFIER.test(name)) {
+        throw new BooksError(`bad_identifier: ${name} is not a plain column or table name`);
+    }
+    return name;
+}
+/** `amount::text` reads back as `amount`; every other column is itself. */
+export function columnName(column) {
+    const cast = column.indexOf('::');
+    return identifier(cast === -1 ? column : column.slice(0, cast));
+}
+//# sourceMappingURL=backend.js.map

package/dist/books/backend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.js","sourceRoot":"","sources":["../../src/books/backend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AA+DH;;;;;;;GAOG;AACH,MAAM,OAAO,UAAW,SAAQ,KAAK;IAC1B,IAAI,GAAG,YAAY,CAAC;IACpB,IAAI,CAAqB;IACzB,IAAI,CAAqB;IAElC,YAAY,OAAe,EAAE,UAAwD,EAAE;QACrF,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QACzB,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC3B,CAAC;CACF;AAED,MAAM,UAAU,GAAG,oBAAoB,CAAC;AAExC;;;;;;GAMG;AACH;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,MAA0B,EAAE,IAAY;IAChE,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;AAC/F,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,UAAU,CAAC,mBAAmB,IAAI,sCAAsC,CAAC,CAAC;IACtF,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,UAAU,CAAC,MAAc;IACvC,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,OAAO,UAAU,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;AAClE,CAAC"}

package/dist/books/columns.d.ts

@@ -0,0 +1,68 @@
+/**
+ * What each tool reads back, written once.
+ *
+ * Two rules run through every list. A `numeric` column is asked for as
+ * `amount::text`, so the exact decimal arrives rather than a float; a `date`
+ * or a timestamp likewise, so `2026-06-15` is a string on both routes instead
+ * of whatever a driver decided a date object should be. Everything else —
+ * uuid, text, boolean, integer — crosses unchanged.
+ */
+export declare const COMPANY: string[];
+export declare const FISCAL_YEAR: string[];
+export declare const ACCOUNT: string[];
+export declare const JOURNAL: string[];
+export declare const CONTACT: string[];
+export declare const TAX: string[];
+export declare const DOCUMENT: string[];
+/**
+ * The mentions the law of a country puts on one document, from the view that
+ * decides which of them apply. `text` is the sentence in the language the
+ * document was written in and `language` says which one that is; `text_i18n`
+ * crosses as it is, for a renderer printing a second language beside it.
+ */
+export declare const DOCUMENT_LEGAL_MENTION: string[];
+/**
+ * What the country of a document requires of it, beside the mentions: the
+ * payment term the law sets, how the number is built, when the tax falls due
+ * and how the document is exchanged. Read from `country_defaults`, which
+ * holds null wherever the pack has said nothing — and null is the answer, not
+ * an invitation to substitute another country's.
+ */
+export declare const COUNTRY_DOCUMENT_RULES: string[];
+/**
+ * The header of a document, from the view that assembles it: the seller, the
+ * buyer, the amounts, where it is paid and what the country of the document
+ * requires. `document_line_items` is the lines and `document_legal_mentions`
+ * the sentences — three reads, and no client holding a copy of the
+ * letterhead.
+ */
+export declare const DOCUMENT_HEADER: string[];
+export declare const PRODUCT: string[];
+export declare const DOCUMENT_LINE: string[];
+export declare const ENTRY: string[];
+export declare const ENTRY_LINE: string[];
+export declare const BANK_ACCOUNT: string[];
+export declare const BANK_TRANSACTION: string[];
+export declare const PAYMENT: string[];
+/**
+ * An invitation, without its secret. `token_hash` is deliberately absent: it
+ * is of no use to a client, and a list of hashes is a thing to leak rather
+ * than a thing to show.
+ */
+/** What one person chose for themselves. Null everywhere is the fresh state. */
+export declare const USER_PREFERENCES: string[];
+export declare const INVITATION: string[];
+/** A machine key, without its hash. The secret is returned once, elsewhere. */
+export declare const API_KEY: string[];
+/** A public link onto a document, without its secret. There is only a hash. */
+export declare const DOCUMENT_SHARE: string[];
+export declare const INSTANCE: string[];
+export declare const RECONCILIATION: string[];
+export declare const AUDIT_LOG: string[];
+/**
+ * `country_packs` — which pack this installation holds, and where its rules
+ * come from. `sources` is the register the pack declares: a reader that wants
+ * to check a rate rather than trust it starts there.
+ */
+export declare const COUNTRY_PACK: string[];
+//# sourceMappingURL=columns.d.ts.map

package/dist/books/columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columns.d.ts","sourceRoot":"","sources":["../../src/books/columns.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,OAAO,UAqCnB,CAAC;AAEF,eAAO,MAAM,WAAW,UAAoE,CAAC;AAE7F,eAAO,MAAM,OAAO,UAUnB,CAAC;AAEF,eAAO,MAAM,OAAO,UAAmD,CAAC;AAExE,eAAO,MAAM,OAAO,UAcnB,CAAC;AAEF,eAAO,MAAM,GAAG,UAsBf,CAAC;AAEF,eAAO,MAAM,QAAQ,UAwBpB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,UAQlC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,UAWlC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,UAoE3B,CAAC;AAEF,eAAO,MAAM,OAAO,UAgBnB,CAAC;AAEF,eAAO,MAAM,aAAa,UAmBzB,CAAC;AAEF,eAAO,MAAM,KAAK,UAejB,CAAC;AAEF,eAAO,MAAM,UAAU,UAsBtB,CAAC;AAEF,eAAO,MAAM,YAAY,UAUxB,CAAC;AAEF,eAAO,MAAM,gBAAgB,UAiB5B,CAAC;AAEF,eAAO,MAAM,OAAO,UAgBnB,CAAC;AAEF;;;;GAIG;AACH,gFAAgF;AAChF,eAAO,MAAM,gBAAgB,UAS5B,CAAC;AAEF,eAAO,MAAM,UAAU,UAYtB,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,OAAO,UAWnB,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,cAAc,UAW1B,CAAC;AAEF,eAAO,MAAM,QAAQ,UAQpB,CAAC;AAEF,eAAO,MAAM,cAAc,UAa1B,CAAC;AAEF,eAAO,MAAM,SAAS,UAarB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,UAYxB,CAAC"}