@wirecat/cli-core 0.574.0 → 0.576.0

package/dist/store/sqlite/mail-findings.js

@@ -5,9 +5,11 @@ import { MAIL_FINDINGS_PER_SENDER, mailFindingFingerprint, validateMailFindings,
 import { findingHash } from "../../meetings/index.js";
 import { assertMayDecide } from "../decisions.js";
 import { MAIL_FINDINGS_KIND } from "../mail-findings.js";
+import { financeOperationsOver } from "./finance.js";
 import { findingsAgent, findingsCoreOver } from "./findings-core.js";
-import { authorActor, memoriesStoreOver } from "./memories.js";
+import { authorActor, linkEvidence, memoriesStoreOver } from "./memories.js";
 import { insertLink, requiredThing } from "./notes.js";
+import { orderOfShop, orderOperationsOver } from "./orders.js";
 import { linkIdentityToPerson } from "./person-links.js";
 import { proposalOperationsOver } from "./proposed-actions.js";
 import { addComment } from "./task-comments.js";
@@ -35,6 +37,8 @@ export const mailFindingsStoreOver = (context) => {
     const core = findingsCoreOver(context, MAIL_FINDINGS_KIND);
     const memories = memoriesStoreOver(context);
     const tasks = workTaskOperationsOver(context);
+    const finance = financeOperationsOver(context);
+    const orders = orderOperationsOver(context);
     const mailbox = (key) => {
         if (key?.provider !== "email" || typeof key.account !== "string" || !key.account.trim())
             return invalid("mail findings belong to one email account");
@@ -135,6 +139,60 @@ export const mailFindingsStoreOver = (context) => {
         }
         return read;
     };
+    /** The invoice, payment or order an accepted finding records: the owner's own entry, citing the mail it came from. */
+    const entry = (finding, evidence) => {
+        const by = "owner";
+        switch (finding.kind) {
+            case "invoice":
+                return () => finance.addInvoice({
+                    by,
+                    evidence,
+                    direction: finding.direction,
+                    counterparty: finding.counterparty,
+                    currency: finding.currency,
+                    lines: finding.lines,
+                    ...(finding.total === undefined ? {} : { total: finding.total }),
+                    ...(finding.number === undefined ? {} : { number: finding.number }),
+                    ...(finding.issueDate === undefined ? {} : { issueDate: finding.issueDate }),
+                    ...(finding.dueDate === undefined ? {} : { dueDate: finding.dueDate }),
+                    ...(finding.project === undefined ? {} : { project: finding.project }),
+                });
+            case "payment":
+                return () => finance.addPayment({
+                    by,
+                    evidence,
+                    direction: finding.direction,
+                    amount: finding.amount,
+                    currency: finding.currency,
+                    date: finding.date,
+                    ...(finding.payer === undefined ? {} : { payer: finding.payer }),
+                    ...(finding.payee === undefined ? {} : { payee: finding.payee }),
+                    ...(finding.reference === undefined ? {} : { reference: finding.reference }),
+                    ...(finding.allocations === undefined ? {} : { allocations: finding.allocations }),
+                    ...(finding.project === undefined ? {} : { project: finding.project }),
+                });
+            case "order": {
+                const { id: _id, kind: _kind, evidence: _cited, reason: _reason, ...fields } = finding;
+                return () => orders.add({ ...fields, by, evidence });
+            }
+            default:
+                return undefined;
+        }
+    };
+    /** Runs what accepting would write and rolls it back, so staging refuses what the owner's accept would refuse. */
+    const ROLLBACK = Symbol("rollback");
+    const wouldWrite = (make) => {
+        try {
+            write(database, () => {
+                make();
+                throw ROLLBACK;
+            });
+        }
+        catch (error) {
+            if (error !== ROLLBACK)
+                throw error;
+        }
+    };
     const identityOfAddress = (address) => database
         .prepare("SELECT i.id, l.person_id FROM identities i LEFT JOIN identity_links l ON l.identity_id = i.id " +
         "WHERE i.provider = 'email' AND lower(i.external_id) = ?")
@@ -163,6 +221,14 @@ export const mailFindingsStoreOver = (context) => {
                 thing(finding.from, "the link's source");
                 thing(finding.to, "the link's target");
                 return;
+            case "invoice":
+            case "payment":
+            case "order":
+                wouldWrite(entry(finding, finding.evidence.map((one) => one.reference)));
+                return;
+            case "order_update":
+                orderOfShop(context, finding.supplierName, finding.number);
+                return;
             case "new_contact": {
                 const ids = finding.evidence.map(({ reference }) => Number(read.get(reference)?.id));
                 const marks = ids.map(() => "?").join(",");
@@ -230,6 +296,20 @@ export const mailFindingsStoreOver = (context) => {
                     database.prepare("UPDATE links SET confirmed = 1, updated_at = ? WHERE id = ?").run(now(), Number(link.id));
                 return `link:${link.id}`;
             }
+            case "invoice":
+            case "payment":
+            case "order":
+                return entry(finding, evidence)().ref;
+            case "order_update": {
+                const order = orderOfShop(context, finding.supplierName, finding.number);
+                orders.setStatus(order, {
+                    status: finding.status,
+                    by: "owner",
+                    ...(finding.date === undefined ? {} : { date: finding.date }),
+                });
+                linkEvidence(context, { type: "order", id: Number(order.slice("order:".length)) }, evidence, "owner");
+                return order;
+            }
             case "new_contact": {
                 const person = Number(identityOfAddress(finding.address)?.person_id);
                 database.prepare("UPDATE persons SET name = ?, updated_at = ? WHERE id = ?").run(finding.name, now(), person);

package/dist/store/sqlite/manifest.js

@@ -65,6 +65,8 @@ export const MANIFEST = [
     { name: "20261102192959_version-47-records", version: 47, minCompatible: 34 },
     { name: "20261102222340_version-48-test-accounts", version: 48, minCompatible: 34 },
     { name: "20261104232153_version-49-relation-amounts", version: 49, minCompatible: 34 },
+    { name: "20261105125314_version-50-orders", version: 50, minCompatible: 34 },
+    { name: "20261105125315_version-50-orders-rules", version: 50, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/migrations.generated.js

@@ -954,5 +954,25 @@ export const GENERATED = [
         "statements": [
             "ALTER TABLE `record_relations` ADD `amount` text;"
         ]
+    },
+    {
+        "name": "20261105125314_version-50-orders",
+        "statements": [
+            "CREATE TABLE `orders` (\n\t`id` integer PRIMARY KEY,\n\t`customer_type` text NOT NULL,\n\t`customer_id` integer NOT NULL,\n\t`purpose` text NOT NULL,\n\t`supplier_type` text,\n\t`supplier_id` integer,\n\t`supplier_name` text NOT NULL,\n\t`number` text,\n\t`currency` text,\n\t`total` integer,\n\t`status` text NOT NULL,\n\t`order_date` text,\n\t`fulfilled_date` text,\n\t`invoice_id` integer,\n\t`payment_id` integer,\n\t`project_id` integer,\n\t`review` text NOT NULL,\n\t`author_type` text NOT NULL,\n\t`author_id` integer NOT NULL,\n\t`model` text,\n\t`confirmed_by_type` text,\n\t`confirmed_by_id` integer,\n\t`source` text NOT NULL,\n\t`metadata` text,\n\t`created_at` integer NOT NULL,\n\t`updated_at` integer NOT NULL,\n\t`deleted_at` integer,\n\tCONSTRAINT `fk_orders_invoice_id_invoices_id_fk` FOREIGN KEY (`invoice_id`) REFERENCES `invoices`(`id`),\n\tCONSTRAINT `fk_orders_payment_id_payments_id_fk` FOREIGN KEY (`payment_id`) REFERENCES `payments`(`id`),\n\tCONSTRAINT `fk_orders_project_id_projects_id_fk` FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`)\n);",
+            "CREATE INDEX `orders_by_customer_type_customer_id` ON `orders` (`customer_type`,`customer_id`);",
+            "CREATE INDEX `orders_by_supplier_type_supplier_id` ON `orders` (`supplier_type`,`supplier_id`);",
+            "CREATE INDEX `orders_by_invoice_id` ON `orders` (`invoice_id`);",
+            "CREATE INDEX `orders_by_payment_id` ON `orders` (`payment_id`);",
+            "CREATE INDEX `orders_by_project_id` ON `orders` (`project_id`);",
+            "CREATE INDEX `orders_by_author_type_author_id` ON `orders` (`author_type`,`author_id`);",
+            "CREATE INDEX `orders_by_confirmed_by_type_confirmed_by_id` ON `orders` (`confirmed_by_type`,`confirmed_by_id`);"
+        ]
+    },
+    {
+        "name": "20261105125315_version-50-orders-rules",
+        "statements": [
+            "-- The store's code checks these first and says why; the triggers keep a stray write from another build or a hand\n-- edit from storing an order with an unknown status or purpose, or an amount without its currency.\nCREATE TRIGGER orders_valid_bi BEFORE INSERT ON orders\n  WHEN new.customer_type NOT IN ('person', 'organization')\n    OR new.purpose NOT IN ('personal', 'business', 'client', 'other')\n    OR new.status NOT IN ('placed', 'shipped', 'delivered', 'cancelled', 'returned')\n    OR new.review NOT IN ('proposed', 'confirmed', 'rejected')\n    OR (new.total IS NULL) <> (new.currency IS NULL) OR new.total < 0 BEGIN\n  SELECT RAISE(ABORT, 'orders: a person or organization customer, a known purpose, status and review, an amount with its currency');\nEND;",
+            "CREATE TRIGGER orders_valid_bu BEFORE UPDATE ON orders\n  WHEN new.customer_type NOT IN ('person', 'organization')\n    OR new.purpose NOT IN ('personal', 'business', 'client', 'other')\n    OR new.status NOT IN ('placed', 'shipped', 'delivered', 'cancelled', 'returned')\n    OR new.review NOT IN ('proposed', 'confirmed', 'rejected')\n    OR (new.total IS NULL) <> (new.currency IS NULL) OR new.total < 0 BEGIN\n  SELECT RAISE(ABORT, 'orders: a person or organization customer, a known purpose, status and review, an amount with its currency');\nEND;"
+        ]
     }
 ];

package/dist/store/sqlite/orders.d.ts

@@ -0,0 +1,84 @@
+import { type FinanceReview } from "../../domain/finance.js";
+import { type OrderPurpose, type OrderStatus } from "../../domain/orders.js";
+import { type Decider } from "../decisions.js";
+import { type ProposedByFilter } from "./actors.js";
+import { type Party, type Reviewed, type Written } from "./finance.js";
+import { type Author } from "./memories.js";
+import type { StoreContext } from "./open.js";
+export interface Order extends Reviewed {
+    id: string;
+    ref: string;
+    /** One line, as a list or the review inbox prints it. */
+    title: string;
+    /** Whom it is for: the owner's own person for his own purchase. */
+    customer: Party;
+    purpose: OrderPurpose;
+    supplier: Party | null;
+    /** The shop or supplier as its mail names it. */
+    supplierName: string;
+    number: string | null;
+    /** Both `null` when the mail gave no amount. */
+    currency: string | null;
+    total: string | null;
+    status: OrderStatus;
+    /** `YYYY-MM-DD`. */
+    orderDate: string | null;
+    fulfilledDate: string | null;
+    invoice: string | null;
+    payment: string | null;
+}
+export interface OrderInput extends Written {
+    /** `person:` or `organization:`; the owner's own person when left out. */
+    customer?: string;
+    purpose: OrderPurpose;
+    supplier?: string;
+    supplierName: string;
+    number?: string;
+    /** A decimal string in `currency`; give both or neither. */
+    total?: string;
+    currency?: string;
+    /** `placed` when left out. */
+    status?: OrderStatus;
+    orderDate?: string;
+    fulfilledDate?: string;
+    invoice?: string;
+    payment?: string;
+}
+export interface OrderFilter {
+    status?: OrderStatus;
+    purpose?: OrderPurpose;
+    customer?: string;
+    /** The shop's name in any letter case; with `number`, how a later mail finds its order. */
+    supplierName?: string;
+    number?: string;
+    project?: string;
+    review?: FinanceReview;
+    proposedBy?: ProposedByFilter;
+    /** 1–500, 100 by default; newest written first. */
+    limit?: number;
+}
+/**
+ * What the owner, his business or a client ordered, from whom, and how far delivery got. The owner's entry is
+ * confirmed at once; an agent's waits as proposed for him, and only he decides it.
+ */
+export interface OrdersStore {
+    add(input: OrderInput): Promise<Order>;
+    get(reference: string): Promise<Order>;
+    list(filter?: OrderFilter): Promise<Order[]>;
+    /** The owner moves an order on, such as a later mail saying it shipped; `date` is the delivery day. */
+    setStatus(reference: string, input: {
+        status: OrderStatus;
+        date?: string;
+        by: Author;
+    }): Promise<Order>;
+    confirm(reference: string, by: Decider, reason?: string): Promise<Order>;
+    reject(reference: string, by: Decider, reason?: string): Promise<Order>;
+}
+type OrderOperations = {
+    [K in keyof OrdersStore]: OrdersStore[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R : never;
+};
+export declare const orderOperationsOver: (context: StoreContext) => OrderOperations;
+/** The one stored order of a shop with a number, as a later mail names it; refuses none and more than one. */
+export declare const orderOfShop: (context: StoreContext, supplierName: string, number: string) => string;
+export declare const ordersStoreOver: (context: StoreContext) => OrdersStore;
+export {};

package/dist/store/sqlite/orders.js

@@ -0,0 +1,186 @@
+import { CliError } from "@wirecat/cli-base";
+import { FINANCE_REVIEWS } from "../../domain/finance.js";
+import { currencyOf, formatDecimal, minorUnits, scaleOf } from "../../domain/money.js";
+import { ORDER_PURPOSES, ORDER_STATUSES, orderTitle } from "../../domain/orders.js";
+import { assertMayDecide, deciderAuthor } from "../decisions.js";
+import { fold } from "../normalize.js";
+import { ownerPerson, proposedBySql, proposerOf } from "./actors.js";
+import { isoDate, oneOf, refuse, reviewedRowsOver, text } from "./finance.js";
+import { authorActor, projectId } from "./memories.js";
+import { requiredThing } from "./notes.js";
+import { write } from "./transaction.js";
+const ORDERS = "SELECT o.*, b.name AS author_name, b.kind AS author_kind FROM orders o " +
+    "LEFT JOIN bots b ON o.author_type = 'bot' AND b.id = o.author_id";
+export const orderOperationsOver = (context) => {
+    const { database, now } = context;
+    const { partyOf, partyThing, reviewedOf, written, keepEvidence, ownerOnly, keepDecision } = reviewedRowsOver(context);
+    const orderOf = (row) => {
+        const currency = row.currency == null ? null : String(row.currency);
+        const total = row.total == null || currency === null ? null : Number(row.total);
+        const fields = {
+            id: Number(row.id),
+            number: row.number == null ? null : String(row.number),
+            supplierName: String(row.supplier_name),
+            total,
+            currency,
+            status: row.status,
+            review: row.review,
+        };
+        return {
+            id: String(row.id),
+            ref: `order:${row.id}`,
+            title: orderTitle(fields),
+            customer: partyOf(row.customer_type, row.customer_id),
+            purpose: row.purpose,
+            supplier: partyOf(row.supplier_type, row.supplier_id),
+            supplierName: fields.supplierName,
+            number: fields.number,
+            currency,
+            total: total === null || currency === null ? null : formatDecimal(total, scaleOf(currency)),
+            status: fields.status,
+            orderDate: row.order_date == null ? null : String(row.order_date),
+            fulfilledDate: row.fulfilled_date == null ? null : String(row.fulfilled_date),
+            invoice: row.invoice_id == null ? null : `invoice:${row.invoice_id}`,
+            payment: row.payment_id == null ? null : `payment:${row.payment_id}`,
+            ...reviewedOf(row, "order"),
+        };
+    };
+    const rowOf = (reference) => {
+        const thing = requiredThing(database, reference.includes(":") ? reference : `order:${reference}`, "the order");
+        if (thing.type !== "order")
+            return refuse(`${reference} is not an order`, "order.ref");
+        return database.prepare(`${ORDERS} WHERE o.id = ?`).get(thing.id);
+    };
+    const linked = (reference, type) => {
+        if (reference === undefined)
+            return null;
+        const thing = requiredThing(database, reference, `the ${type}`);
+        if (thing.type !== type)
+            return refuse(`${reference} is not an ${type}: reference`, "order.ref");
+        return thing.id;
+    };
+    const statusOf = (value) => oneOf(value, ORDER_STATUSES, "an order's status");
+    const decide = (reference, by, reason, confirm) => {
+        const row = rowOf(reference);
+        const ref = `order:${row.id}`;
+        assertMayDecide({ id: ref, proposedBy: proposerOf(database, row.author_type, row.author_id), ownerOnly: true }, by, context.decisions);
+        if (row.review !== "proposed")
+            refuse(`${ref} is already ${String(row.review)}`, "proposal.wrong-state");
+        write(database, () => {
+            if (confirm) {
+                const { actor } = authorActor(context, deciderAuthor(by));
+                database
+                    .prepare("UPDATE orders SET review = 'confirmed', confirmed_by_type = ?, confirmed_by_id = ?, updated_at = ? WHERE id = ?")
+                    .run(actor.type, actor.id, now(), Number(row.id));
+            }
+            else
+                database
+                    .prepare("UPDATE orders SET review = 'rejected', updated_at = ? WHERE id = ?")
+                    .run(now(), Number(row.id));
+            keepDecision("orders", Number(row.id), by, reason);
+        });
+        return orderOf(rowOf(ref));
+    };
+    return {
+        add: (input) => {
+            const purpose = oneOf(input.purpose, ORDER_PURPOSES, "an order's purpose");
+            const status = input.status === undefined ? "placed" : statusOf(input.status);
+            const supplierName = text(input.supplierName, "an order's supplier name", 200) ??
+                refuse("an order names its shop or supplier", "order.field");
+            const number = text(input.number, "an order's number", 80);
+            if ((input.total === undefined) !== (input.currency === undefined))
+                refuse("an order's amount and currency come together", "order.field");
+            const currency = input.currency === undefined ? null : currencyOf(input.currency);
+            const total = currency === null ? null : minorUnits(input.total, currency, "an order's amount");
+            if (total !== null && total < 0)
+                refuse("an order's amount is 0 or more", "money.amount");
+            const orderDate = isoDate(input.orderDate, "an order's date");
+            const fulfilledDate = isoDate(input.fulfilledDate, "an order's delivery date");
+            const id = write(database, () => {
+                if (number !== null && ordersOfShop(database, supplierName, number).length)
+                    refuse(`order ${number} from ${supplierName} is already stored; change its status instead`, "order.duplicate");
+                const customer = partyThing(input.customer, "the customer") ?? ownerPerson(database);
+                const supplier = partyThing(input.supplier, "the supplier");
+                const invoice = linked(input.invoice, "invoice");
+                const payment = linked(input.payment, "payment");
+                const by = written(input);
+                const at = now();
+                const made = Number(database
+                    .prepare("INSERT INTO orders (customer_type, customer_id, purpose, supplier_type, supplier_id, supplier_name, number, " +
+                    "currency, total, status, order_date, fulfilled_date, invoice_id, payment_id, project_id, review, " +
+                    "author_type, author_id, model, confirmed_by_type, confirmed_by_id, source, metadata, created_at, updated_at) " +
+                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
+                    .get(customer.type, customer.id, purpose, supplier?.type ?? null, supplier?.id ?? null, supplierName, number, currency, total, status, orderDate, fulfilledDate, invoice, payment, by.project, by.review, by.actor.type, by.actor.id, by.model, by.confirmedType, by.confirmedId, by.source, by.metadata, at, at)?.id);
+                keepEvidence("order", made, by);
+                return made;
+            });
+            return orderOf(rowOf(`order:${id}`));
+        },
+        get: (reference) => orderOf(rowOf(reference)),
+        list: (filter = {}) => {
+            const project = filter.project === undefined ? null : projectId(database, filter.project);
+            const customer = partyThing(filter.customer, "the customer");
+            const by = proposedBySql("o.author_type", "o.author_id", filter.proposedBy);
+            const status = filter.status === undefined ? null : statusOf(filter.status);
+            const purpose = filter.purpose === undefined ? null : oneOf(filter.purpose, ORDER_PURPOSES, "a purpose");
+            const review = filter.review === undefined ? null : oneOf(filter.review, FINANCE_REVIEWS, "a review");
+            const number = filter.number === undefined ? null : filter.number.trim();
+            const shop = filter.supplierName === undefined ? null : fold(filter.supplierName);
+            const limit = Math.min(Math.max(filter.limit ?? 100, 1), 500);
+            const rows = database
+                .prepare(`${ORDERS} WHERE o.deleted_at IS NULL AND (? IS NULL OR o.status = ?) AND (? IS NULL OR o.purpose = ?) ` +
+                "AND (? IS NULL OR o.review = ?) AND (? IS NULL OR o.project_id = ?) AND (? IS NULL OR o.number = ?) " +
+                "AND (? IS NULL OR (o.customer_type = ? AND o.customer_id = ?)) " +
+                `AND ${by.sql} ORDER BY o.created_at DESC, o.id DESC`)
+                .all(status, status, purpose, purpose, review, review, project, project, number, number, customer?.type ?? null, customer?.type ?? null, customer?.id ?? null, ...by.params);
+            return rows
+                .filter((row) => shop === null || fold(String(row.supplier_name)) === shop)
+                .slice(0, limit)
+                .map(orderOf);
+        },
+        setStatus: (reference, { status, date, by }) => {
+            ownerOnly(by, "moves an order on");
+            const next = statusOf(status);
+            const day = isoDate(date, "an order's delivery date");
+            const row = rowOf(reference);
+            if (row.review === "rejected" || row.deleted_at != null)
+                refuse(`order:${row.id} is ${row.deleted_at != null ? "deleted" : "rejected"}`, "order.status");
+            write(database, () => {
+                database
+                    .prepare("UPDATE orders SET status = ?, fulfilled_date = coalesce(?, fulfilled_date), updated_at = ? WHERE id = ?")
+                    .run(next, next === "delivered" ? day : null, now(), Number(row.id));
+            });
+            return orderOf(rowOf(`order:${row.id}`));
+        },
+        confirm: (reference, by, reason) => decide(reference, by, reason, true),
+        reject: (reference, by, reason) => decide(reference, by, reason, false),
+    };
+};
+/** Orders of one shop with one number that still count: neither rejected nor deleted, the name in any letter case. */
+const ordersOfShop = (database, supplierName, number) => {
+    const name = fold(supplierName);
+    return database
+        .prepare("SELECT id, supplier_name FROM orders WHERE number = ? AND deleted_at IS NULL AND review <> 'rejected'")
+        .all(number.trim())
+        .filter((row) => fold(String(row.supplier_name)) === name);
+};
+/** The one stored order of a shop with a number, as a later mail names it; refuses none and more than one. */
+export const orderOfShop = (context, supplierName, number) => {
+    const rows = ordersOfShop(context.database, supplierName, number);
+    if (rows.length === 0)
+        throw new CliError("not_found", `no stored order ${number} from ${supplierName}`, { reason: "order.not-found" });
+    if (rows.length > 1)
+        return refuse(`more than one order ${number} from ${supplierName}`, "order.ref");
+    return `order:${rows[0]?.id}`;
+};
+export const ordersStoreOver = (context) => {
+    const operations = orderOperationsOver(context);
+    return {
+        add: async (input) => operations.add(input),
+        get: async (reference) => operations.get(reference),
+        list: async (filter) => operations.list(filter),
+        setStatus: async (reference, input) => operations.setStatus(reference, input),
+        confirm: async (reference, by, reason) => operations.confirm(reference, by, reason),
+        reject: async (reference, by, reason) => operations.reject(reference, by, reason),
+    };
+};

package/dist/store/sqlite/ref-summaries.js

@@ -1,4 +1,5 @@
 import { invoiceLine, paymentLine } from "../../domain/finance.js";
+import { orderLine } from "../../domain/orders.js";
 import { filesAccountSql, providerLabel, providerNamed } from "../../domain/providers.js";
 import { oneLine } from "../../domain/ref-summaries.js";
 import { formatReference, parseReference } from "../../domain/references.js";
@@ -199,6 +200,13 @@ const READERS = {
         at: "x.created_at",
         deleted: "x.deleted_at",
     })),
+    order: byId("order", "orders", () => ({
+        title: "json_object('id', x.id, 'number', x.number, 'supplierName', x.supplier_name, 'total', x.total, " +
+            "'currency', x.currency, 'status', x.status, 'review', x.review)",
+        holder: "(SELECT name FROM projects WHERE id = x.project_id)",
+        at: "x.created_at",
+        deleted: "x.deleted_at",
+    })),
 };
 /** Mail saved before the mail tables existed is still messages, so a miss there is read again as a message. */
 const FALLBACK = { email: "message", email_thread: "chat" };
@@ -304,6 +312,8 @@ const titleOf = (kind, reference, found) => {
             return fieldsOf(found.title, invoiceLine);
         case "payment":
             return fieldsOf(found.title, paymentLine);
+        case "order":
+            return fieldsOf(found.title, orderLine);
         case "folder":
             return reference.type === "folder" && reference.path !== null && found.title !== null
                 ? `${found.title}/${reference.path}`