@wirecat/cli-core 0.555.0 → 0.557.0

package/dist/store/sqlite/email-activity.d.ts

@@ -36,7 +36,37 @@ export interface EmailMarks {
     /** The mail rule that decided how it is stored, by its id in `rules list`. */
     ruleId: number | null;
 }
+/** One email as a processing mark sees it, by its store id; never its text. */
+export interface MarkedEmail {
+    id: number;
+    externalId: string;
+    thread: string;
+    /** ms: received, or sent when that is unknown. */
+    at: number | null;
+    /** ms: when the store saved it first, and last changed it. */
+    storedAt: number;
+    changedAt: number;
+    /** Sent to many: the bulk mailbox or a List-Id. */
+    bulk: boolean;
+    envelope: boolean;
+    /** Stored from its first bytes, not whole yet. */
+    partial: boolean;
+    draft: boolean;
+}
 export interface MailActivityStore {
+    /**
+     * The account's live emails stored after `afterId`, oldest first, at most `limit`, and those of `ids`: what a
+     * processing mark reads next. The id is the store's insert order, so mail stored late is never behind the mark.
+     */
+    emailsAfter(accountId: number, afterId: number, limit: number, ids?: readonly number[]): Promise<MarkedEmail[]>;
+    /** The account's newest store id; 0 with no mail. */
+    newestEmailId(accountId: number): Promise<number>;
+    /** Every `sync_cursors` value of the account whose key starts with `prefix`. */
+    statesLike(accountId: number, prefix: string): Promise<{
+        key: string;
+        value: string;
+        at: number;
+    }[]>;
     /** Each live email's marks, by its Message-ID; one the store does not hold is left out. */
     emailMarks(accountId: number, externalIds: readonly string[]): Promise<Map<string, EmailMarks>>;
     /**
@@ -59,4 +89,5 @@ export declare const threadEmailIds: (database: CacheDatabase, accountId: number
     until?: number;
 }) => number[];
 export declare const emailMarks: (database: CacheDatabase, accountId: number, externalIds: readonly string[]) => Map<string, EmailMarks>;
+export declare const emailsAfter: (database: CacheDatabase, accountId: number, afterId: number, limit: number, ids?: readonly number[]) => MarkedEmail[];
 export declare const mailActivity: (database: CacheDatabase) => MailActivityStore;

package/dist/store/sqlite/email-activity.js

@@ -65,7 +65,45 @@ export const emailMarks = (database, accountId, externalIds) => {
     }
     return marks;
 };
+const MARKED = `
+  SELECT e.id, e.external_id, t.external_id AS thread, coalesce(e.received_at, e.sent_at) AS at, e.created_at,
+    e.updated_at, coalesce(e.draft, 0) AS draft, json_extract(e.metadata, '$.partial') IS NOT NULL AS partial,
+    coalesce(json_extract(e.headers, '$."list-id"'), json_extract(e.metadata, '$.listId')) IS NOT NULL
+      OR EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
+        WHERE m.email_id = e.id AND b.kind = 'bulk') AS bulk,
+    EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
+      WHERE m.email_id = e.id AND b.kind = 'envelope') AS envelope
+  FROM emails e JOIN email_threads t ON t.id = e.email_thread_id`;
+const markedOf = (row) => ({
+    id: Number(row.id),
+    externalId: String(row.external_id),
+    thread: String(row.thread),
+    at: int(row.at),
+    storedAt: Number(row.created_at),
+    changedAt: Number(row.updated_at),
+    bulk: Boolean(row.bulk),
+    envelope: Boolean(row.envelope),
+    partial: Boolean(row.partial),
+    draft: Boolean(row.draft),
+});
+export const emailsAfter = (database, accountId, afterId, limit, ids = []) => {
+    const next = database
+        .prepare(`${MARKED} WHERE e.id > ? AND e.account_id = ? AND e.deleted_at IS NULL ORDER BY e.id LIMIT ?`)
+        .all(afterId, accountId, limit);
+    const one = database.prepare(`${MARKED} WHERE e.id = ? AND e.account_id = ? AND e.deleted_at IS NULL`);
+    const named = ids.flatMap((id) => {
+        const row = one.get(id, accountId);
+        return row ? [row] : [];
+    });
+    return [...named, ...next].map(markedOf);
+};
 export const mailActivity = (database) => ({
+    emailsAfter: async (accountId, afterId, limit, ids) => emailsAfter(database, accountId, afterId, limit, ids),
+    newestEmailId: async (accountId) => Number(database.prepare("SELECT max(id) AS id FROM emails WHERE account_id = ?").get(accountId)?.id ?? 0),
+    statesLike: async (accountId, prefix) => database
+        .prepare("SELECT key, value, updated_at FROM sync_cursors WHERE account_id = ? AND substr(key, 1, ?) = ?")
+        .all(accountId, prefix.length, prefix)
+        .map((row) => ({ key: String(row.key), value: String(row.value), at: Number(row.updated_at) })),
     emailMarks: async (accountId, externalIds) => emailMarks(database, accountId, externalIds),
     threadActivity: async (accountId, since, where) => threadActivity(database, accountId, since, where),
 });

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

@@ -269,6 +269,8 @@ export interface MailStore extends PartialMailStore, MailActivityStore {
     }[]>;
     /** Live emails of one account by Message-ID, each placed in its thread; an unknown one is left out. */
     inThreads(accountId: number, externalIds: string[]): Promise<EmailInThread[]>;
+    /** Emails by store id, as search hits in the order given; one the store does not hold is left out. */
+    emailHits(ids: readonly number[]): Promise<StoredHit[]>;
     /** A thread's live emails, oldest first, as search hits; `window` keeps those received in (after, until], in ms. */
     threadHits(accountId: number, thread: string, window?: {
         after?: number;

package/dist/store/sqlite/emails.js

@@ -633,6 +633,7 @@ export const mailStoreOver = ({ database, orm, now }, stemmerFor = stemmerCache(
             return place ? [{ ...place, score }] : [];
         });
     },
+    emailHits: async (ids) => emailHitsByPk(database, [...ids]),
     async threadHits(accountId, thread, window) {
         return emailHitsByPk(database, threadEmailIds(database, accountId, thread, window));
     },

package/dist/store/sqlite/entity-types.d.ts

@@ -20,6 +20,7 @@ export declare const ENTITY_TABLES: {
     readonly file: "files";
     readonly identity: "identities";
     readonly image: "attachments";
+    readonly invoice: "invoices";
     readonly meeting: "meetings";
     readonly meeting_transcript: "meeting_transcripts";
     readonly meeting_transcript_row: "meeting_transcript_rows";
@@ -27,6 +28,7 @@ export declare const ENTITY_TABLES: {
     readonly message: "messages";
     readonly note: "notes";
     readonly organization: "organizations";
+    readonly payment: "payments";
     readonly person: "persons";
     readonly place: "places";
     readonly project: "projects";

package/dist/store/sqlite/entity-types.js

@@ -19,6 +19,7 @@ export const ENTITY_TABLES = {
     file: "files",
     identity: "identities",
     image: "attachments",
+    invoice: "invoices",
     meeting: "meetings",
     meeting_transcript: "meeting_transcripts",
     meeting_transcript_row: "meeting_transcript_rows",
@@ -26,6 +27,7 @@ export const ENTITY_TABLES = {
     message: "messages",
     note: "notes",
     organization: "organizations",
+    payment: "payments",
     person: "persons",
     place: "places",
     project: "projects",

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

@@ -0,0 +1,199 @@
+import { type FinanceReview, type InvoiceDirection, type InvoiceStatus, type MoneyDirection } from "../../domain/finance.js";
+import { type Money } from "../../domain/money.js";
+import { type Decider } from "../decisions.js";
+import { type Actor, type ProposedByFilter } from "./actors.js";
+import { type Author } from "./memories.js";
+import type { StoreContext } from "./open.js";
+/** A `person:` or `organization:` on an invoice or a payment, with its name so a list needs no lookup. */
+export interface Party {
+    ref: string;
+    name: string | null;
+    /** The owner's own person row. */
+    owner: boolean;
+}
+interface Reviewed {
+    review: FinanceReview;
+    /** `name` is a bot's handle and `kind` whether it is an agent or a rule; both `null` for a person. */
+    author: {
+        type: Actor["type"];
+        id: string;
+        name: string | null;
+        kind: "agent" | "rule" | null;
+    };
+    model: string | null;
+    confirmedBy: {
+        type: Actor["type"];
+        id: string;
+    } | null;
+    source: string;
+    /** Why an agent or an import proposed it. */
+    reason: string | null;
+    project: string | null;
+    projectName: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Invoice extends Reviewed {
+    id: string;
+    ref: string;
+    /** One line, as a list or the review inbox prints it. */
+    title: string;
+    direction: InvoiceDirection;
+    number: string | null;
+    issuer: Party | null;
+    counterparty: Party;
+    currency: string;
+    total: string;
+    /** Settled by confirmed payments. */
+    paid: string;
+    /** Still owed: `total − paid`. */
+    open: string;
+    issueDate: string | null;
+    dueDate: string | null;
+    status: InvoiceStatus;
+}
+export interface InvoiceLine {
+    position: number;
+    description: string;
+    quantity: string;
+    unitPrice: string | null;
+    amount: string;
+}
+export interface Allocation {
+    payment: string;
+    invoice: string;
+    amount: string;
+    currency: string;
+    createdAt: string;
+}
+export interface InvoiceDetail extends Invoice {
+    lines: InvoiceLine[];
+    allocations: Allocation[];
+}
+export interface Payment extends Reviewed {
+    id: string;
+    ref: string;
+    title: string;
+    direction: MoneyDirection;
+    payer: Party | null;
+    payee: Party | null;
+    amount: string;
+    currency: string;
+    /** `YYYY-MM-DD`. */
+    date: string;
+    reference: string | null;
+    /** Allocated to invoices, confirmed or not. */
+    allocated: string;
+    unallocated: string;
+}
+export interface PaymentDetail extends Payment {
+    allocations: Allocation[];
+}
+interface Written {
+    /** The owner's entry is confirmed at once; a bot's waits as proposed for the owner. */
+    by: Author;
+    project?: string;
+    /** Where a bot's row came from, such as `agent` or an importer's name; the owner's is always `owner`. */
+    source?: string;
+    /** Why a bot proposes it, kept for the reviewer. */
+    reason?: string;
+}
+export interface InvoiceLineInput {
+    description: string;
+    /** A decimal string; `1` when not given. */
+    quantity?: string;
+    /** Decimal strings in the invoice's currency. Give either or both: both must agree, quantity × unit price. */
+    unitPrice?: string;
+    amount?: string;
+}
+export interface InvoiceInput extends Written {
+    direction: InvoiceDirection;
+    number?: string;
+    /** `person:` or `organization:`. */
+    issuer?: string;
+    counterparty: string;
+    currency: string;
+    /** `YYYY-MM-DD`. */
+    issueDate?: string;
+    dueDate?: string;
+    /** Kept as a draft until `issueInvoice`; otherwise issued at once. */
+    draft?: boolean;
+    lines: InvoiceLineInput[];
+    /** The total printed on the invoice: refused when it is not the sum of the lines. */
+    total?: string;
+}
+export interface PaymentInput extends Written {
+    direction: MoneyDirection;
+    payer?: string;
+    payee?: string;
+    amount: string;
+    currency: string;
+    date: string;
+    reference?: string;
+    /** Invoices it settles, in the payment's currency; a bot's count only once the owner confirms the payment. */
+    allocations?: {
+        invoice: string;
+        amount: string;
+    }[];
+}
+interface ListFilter {
+    project?: string;
+    review?: FinanceReview;
+    proposedBy?: ProposedByFilter;
+    /** 1–500, 100 by default; newest written first. */
+    limit?: number;
+}
+export interface OpenTotal extends Money {
+    invoices: number;
+}
+export interface FinanceStore {
+    addInvoice(input: InvoiceInput): Promise<InvoiceDetail>;
+    invoice(reference: string): Promise<InvoiceDetail>;
+    invoices(filter?: ListFilter & {
+        direction?: InvoiceDirection;
+        status?: InvoiceStatus;
+        /** Issued or partly paid. */
+        open?: boolean;
+        counterparty?: string;
+    }): Promise<Invoice[]>;
+    /** The owner sends a draft: its status then follows its allocations. */
+    issueInvoice(reference: string, by: Author): Promise<InvoiceDetail>;
+    /** The owner cancels an invoice no confirmed payment is allocated to; proposed allocations to it go. */
+    voidInvoice(reference: string, by: Author): Promise<InvoiceDetail>;
+    addPayment(input: PaymentInput): Promise<PaymentDetail>;
+    payment(reference: string): Promise<PaymentDetail>;
+    payments(filter?: ListFilter & {
+        direction?: MoneyDirection;
+        party?: string;
+    }): Promise<Payment[]>;
+    /**
+     * Settles part of an invoice with part of a payment, in one currency, never beyond either. The owner allocates any
+     * payment; a bot only one it proposed that is still proposed.
+     */
+    allocate(input: {
+        payment: string;
+        invoice: string;
+        amount: string;
+        by: Author;
+    }): Promise<Allocation>;
+    /**
+     * The owner confirms a proposed `invoice:` or `payment:`; only the owner decides money. A payment whose allocations
+     * would settle more than an invoice's total, given the confirmed payments by then, is refused and stays proposed.
+     */
+    confirm(reference: string, by: Decider, reason?: string): Promise<InvoiceDetail | PaymentDetail>;
+    /** The owner turns a proposal down; it stays, `rejected`, and its allocations go. */
+    reject(reference: string, by: Decider, reason?: string): Promise<InvoiceDetail | PaymentDetail>;
+    /** What is still owed on confirmed open invoices, per direction and per currency: nothing is converted. */
+    openTotals(filter?: {
+        project?: string;
+    }): Promise<{
+        receivable: OpenTotal[];
+        payable: OpenTotal[];
+    }>;
+}
+type FinanceOperations = {
+    [K in keyof FinanceStore]: FinanceStore[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R : never;
+};
+export declare const financeOperationsOver: (context: StoreContext) => FinanceOperations;
+export declare const financeStoreOver: (context: StoreContext) => FinanceStore;
+export {};