@wirecat/cli-core 0.587.0 → 0.589.0

package/dist/store/sqlite/deals.js

@@ -1,44 +1,43 @@
 import { CliError } from "@wirecat/cli-base";
-import { DEAL_ROLES, DEAL_STATUSES, dealLine } from "../../domain/deals.js";
-import { FINANCE_REVIEWS } from "../../domain/finance.js";
+import { DEAL_KINDS, DEAL_ROLES, DEAL_STATUSES, dealLine, STAGE_OUTCOMES, } from "../../domain/deals.js";
 import { currencyOf, formatDecimal, minorUnits, scaleOf } from "../../domain/money.js";
-import { assertMayDecide, deciderAuthor } from "../decisions.js";
 import { fold } from "../normalize.js";
-import { proposedBySql, proposerOf } from "./actors.js";
+import { proposedBySql } from "./actors.js";
 import { isoDate, oneOf, refuse, reviewedRowsOver, text } from "./finance.js";
 import { linkKind } from "./link-kinds.js";
-import { authorActor, projectId } from "./memories.js";
+import { authorActor, authorOf, evidenceOf, linkEvidence, projectId, projectOf } from "./memories.js";
 import { requiredThing } from "./notes.js";
 import { write } from "./transaction.js";
-const DEALS = "SELECT d.*, s.name AS stage_name, s.pipeline_id, p.name AS pipeline_name, b.name AS author_name, " +
-    "b.kind AS author_kind FROM opportunities d JOIN pipeline_stages s ON s.id = d.stage_id " +
-    "JOIN pipelines p ON p.id = s.pipeline_id LEFT JOIN bots b ON d.author_type = 'bot' AND b.id = d.author_id";
-const MAX_STAGES = 20;
+const TABLES = { deal: "deals", lead: "leads" };
+const itemsSql = (kind) => "SELECT d.*, s.name AS stage_name, s.pipeline_id, p.name AS pipeline_name, b.name AS author_name, " +
+    "b.kind AS author_kind, a.provider AS account_provider, a.external_id AS account_external_id " +
+    `FROM ${TABLES[kind]} d JOIN pipeline_stages s ON s.id = d.stage_id JOIN pipelines p ON p.id = s.pipeline_id ` +
+    "LEFT JOIN bots b ON d.author_type = 'bot' AND b.id = d.author_id LEFT JOIN accounts a ON a.id = d.account_id";
+const MAX_STAGES = 30;
 const MAX_PEOPLE = 20;
-const ownerOnly = (by, what) => {
-    if (by !== "owner")
-        refuse(`only the owner ${what}`, "deal.owner-only", "permission_error");
+const iso = (value) => new Date(Number(value)).toISOString();
+const jsonField = (metadata, key) => {
+    if (metadata == null)
+        return null;
+    try {
+        const value = JSON.parse(String(metadata))[key];
+        return typeof value === "string" ? value : null;
+    }
+    catch {
+        return null;
+    }
 };
+const accountOf = (provider, external) => provider == null ? null : { provider: String(provider), account: String(external) };
 export const dealOperationsOver = (context) => {
     const { database, now } = context;
-    const { partyOf, partyThing, reviewedOf, written, keepEvidence, keepDecision } = reviewedRowsOver(context);
-    const closedReasonOf = (metadata) => {
-        if (metadata == null)
-            return null;
-        try {
-            const { closed_reason } = JSON.parse(String(metadata));
-            return typeof closed_reason === "string" ? closed_reason : null;
-        }
-        catch {
-            return null;
-        }
-    };
-    const peopleOf = (id) => database
-        .prepare(`SELECT to_id, role FROM links WHERE from_type = 'deal' AND from_id = ? AND kind = ${linkKind("related-to")} ` +
+    const { partyOf, partyThing } = reviewedRowsOver(context);
+    const today = () => new Date(now()).toISOString().slice(0, 10);
+    const peopleOf = (kind, id) => database
+        .prepare(`SELECT to_id, role FROM links WHERE from_type = ? AND from_id = ? AND kind = ${linkKind("related-to")} ` +
         "AND to_type = 'person' AND to_id IS NOT NULL ORDER BY id")
-        .all(id)
+        .all(kind, id)
         .map((row) => ({ ...partyOf("person", row.to_id), role: row.role }));
-    const dealOf = (row) => {
+    const itemOf = (kind) => (row) => {
         const currency = row.currency == null ? null : String(row.currency);
         const amount = row.amount == null || currency === null ? null : Number(row.amount);
         const fields = {
@@ -48,14 +47,15 @@ export const dealOperationsOver = (context) => {
             amount,
             currency,
             status: row.status,
-            review: row.review,
         };
         return {
             id: String(row.id),
-            ref: `deal:${row.id}`,
+            ref: `${kind}:${row.id}`,
+            kind,
             title: fields.title,
             summary: dealLine(fields),
-            pipeline: String(row.pipeline_name),
+            pipeline: `pipeline:${row.pipeline_id}`,
+            pipelineName: String(row.pipeline_name),
             stage: fields.stage,
             status: fields.status,
             organization: partyOf(row.organization_id == null ? null : "organization", row.organization_id),
@@ -63,118 +63,234 @@ export const dealOperationsOver = (context) => {
             amount: amount === null || currency === null ? null : formatDecimal(amount, scaleOf(currency)),
             closeDate: row.close_date == null ? null : String(row.close_date),
             closedDate: row.closed_date == null ? null : String(row.closed_date),
-            closedReason: closedReasonOf(row.metadata),
-            people: peopleOf(fields.id),
-            ...reviewedOf(row, "deal"),
+            closedReason: jsonField(row.metadata, "closed_reason"),
+            rank: row.rank == null ? null : Number(row.rank),
+            deal: row.deal_id == null ? null : `deal:${row.deal_id}`,
+            account: accountOf(row.account_provider, row.account_external_id),
+            externalId: row.external_id == null ? null : String(row.external_id),
+            people: peopleOf(kind, fields.id),
+            author: authorOf(row),
+            model: row.model == null ? null : String(row.model),
+            source: String(row.source),
+            reason: jsonField(row.metadata, "reason"),
+            evidence: evidenceOf(context, { type: kind, id: fields.id }),
+            ...projectOf(database, row),
+            createdAt: iso(row.created_at),
+            updatedAt: iso(row.updated_at),
         };
     };
     const rowOf = (reference) => {
         const thing = requiredThing(database, reference.includes(":") ? reference : `deal:${reference}`, "the deal");
-        if (thing.type !== "deal")
-            return refuse(`${reference} is not a deal`, "deal.ref");
-        return database.prepare(`${DEALS} WHERE d.id = ?`).get(thing.id);
+        if (thing.type !== "deal" && thing.type !== "lead")
+            return refuse(`${reference} is not a deal or a lead`, "deal.ref");
+        return { kind: thing.type, row: database.prepare(`${itemsSql(thing.type)} WHERE d.id = ?`).get(thing.id) };
     };
-    const pipelineNamed = (name) => {
-        const found = database.prepare("SELECT id FROM pipelines WHERE name_folded = ?").get(fold(name.trim()));
-        if (!found)
-            throw new CliError("not_found", `no pipeline named ${name}`, { reason: "pipeline.not-found" });
-        return Number(found.id);
+    const read = (reference) => {
+        const { kind, row } = rowOf(reference);
+        return itemOf(kind)(row);
     };
-    /** A stage by name, in one pipeline when it is named, else in the only pipeline that has one of that name. */
-    const stageNamed = (stage, pipeline) => {
-        const within = typeof pipeline === "string" ? pipelineNamed(pipeline) : (pipeline ?? null);
-        const rows = database
-            .prepare("SELECT id FROM pipeline_stages WHERE name_folded = ? AND (? IS NULL OR pipeline_id = ?)")
-            .all(fold(stage.trim()), within, within);
+    const kindOf = (kind) => (kind === undefined ? "deal" : oneOf(kind, DEAL_KINDS, "a kind"));
+    const pipelineRows = (kind) => database
+        .prepare("SELECT p.*, a.provider AS account_provider, a.external_id AS account_external_id FROM pipelines p " +
+        "LEFT JOIN accounts a ON a.id = p.account_id WHERE (? IS NULL OR p.kind = ?) ORDER BY p.name_folded, p.id")
+        .all(kind ?? null, kind ?? null);
+    const label = (row) => `pipeline:${row.id} (${row.name}${row.account_provider == null ? "" : `, ${row.account_provider}:${row.account_external_id}`})`;
+    /** A pipeline by `pipeline:<id>`, or by a name only one pipeline of the kind has; never a guess. */
+    const pipelineRow = (reference, kind) => {
+        const named = reference.trim();
+        if (/^pipeline:\d+$/.test(named)) {
+            const row = pipelineRows(kind).find((one) => `pipeline:${one.id}` === named);
+            if (!row)
+                throw new CliError("not_found", `no ${kind ?? ""} pipeline ${named}`, { reason: "pipeline.not-found" });
+            return row;
+        }
+        const rows = pipelineRows(kind).filter((one) => one.name_folded === fold(named));
         if (rows.length === 0)
-            return refuse(`no stage named ${stage}${within === null ? "" : " in that pipeline"}`, "deal.stage");
+            throw new CliError("not_found", `no ${kind === undefined ? "" : `${kind} `}pipeline named ${named}`, {
+                reason: "pipeline.not-found",
+            });
         if (rows.length > 1)
-            return refuse(`more than one pipeline has a stage named ${stage}; name the pipeline`, "deal.stage");
-        return Number(rows[0]?.id);
+            return refuse(`more than one pipeline is named ${named}: ${rows.map(label).join(", ")}; name one by its reference`, "pipeline.ambiguous");
+        return rows[0];
     };
-    const pipelinesOf = () => {
-        const stages = database
-            .prepare("SELECT s.pipeline_id, s.name, s.position, (SELECT count(*) FROM opportunities d WHERE d.stage_id = s.id " +
-            "AND d.status = 'open' AND d.review <> 'rejected' AND d.deleted_at IS NULL) AS open " +
-            "FROM pipeline_stages s ORDER BY s.pipeline_id, s.position")
-            .all();
-        return database
-            .prepare("SELECT id, name, created_at FROM pipelines ORDER BY name_folded")
-            .all()
-            .map((pipeline) => ({
-            name: String(pipeline.name),
+    const stagesOf = (pipelineIds) => database
+        .prepare("SELECT s.*, (SELECT count(*) FROM deals d WHERE d.stage_id = s.id AND d.status = 'open' AND d.deleted_at IS NULL) + " +
+        "(SELECT count(*) FROM leads l WHERE l.stage_id = s.id AND l.status = 'open' AND l.deleted_at IS NULL) AS open " +
+        `FROM pipeline_stages s WHERE s.pipeline_id IN (${pipelineIds.map(() => "?").join(", ") || "NULL"}) ` +
+        "ORDER BY s.pipeline_id, s.position, s.id")
+        .all(...pipelineIds);
+    const pipelinesOf = (rows) => {
+        const stages = stagesOf(rows.map((row) => Number(row.id)));
+        return rows.map((row) => ({
+            id: String(row.id),
+            ref: `pipeline:${row.id}`,
+            name: String(row.name),
+            kind: row.kind,
+            account: accountOf(row.account_provider, row.account_external_id),
+            externalId: row.external_id == null ? null : String(row.external_id),
             stages: stages
-                .filter((stage) => stage.pipeline_id === pipeline.id)
-                .map((stage) => ({ name: String(stage.name), position: Number(stage.position), open: Number(stage.open) })),
-            createdAt: new Date(Number(pipeline.created_at)).toISOString(),
+                .filter((stage) => stage.pipeline_id === row.id)
+                .map((stage) => ({
+                name: String(stage.name),
+                position: Number(stage.position),
+                outcome: stage.outcome,
+                externalId: stage.external_id == null ? null : String(stage.external_id),
+                open: Number(stage.open),
+            })),
+            createdAt: iso(row.created_at),
         }));
     };
-    const stillOpen = (row, what) => {
-        if (row.status !== "open" || row.review === "rejected" || row.deleted_at != null)
-            refuse(`deal:${row.id} is ${row.deleted_at != null ? "deleted" : row.review === "rejected" ? "rejected" : String(row.status)}; it no longer ${what}`, "deal.closed");
+    /** A stage by name in one pipeline, or in the only pipeline of the kind that has one of that name. */
+    const stageRow = (stage, kind, pipeline) => {
+        const rows = database
+            .prepare("SELECT s.*, p.name AS pipeline_name FROM pipeline_stages s JOIN pipelines p ON p.id = s.pipeline_id " +
+            "WHERE s.name_folded = ? AND p.kind = ? AND (? IS NULL OR p.id = ?) ORDER BY p.id")
+            .all(fold(stage.trim()), kind, pipeline ?? null, pipeline ?? null);
+        if (rows.length === 0)
+            return refuse(`no stage named ${stage} in ${pipeline === undefined ? `a ${kind} pipeline` : "that pipeline"}`, "deal.stage");
+        if (rows.length > 1)
+            return refuse(`more than one pipeline has a stage named ${stage}: ${rows.map((row) => `pipeline:${row.pipeline_id} (${row.pipeline_name})`).join(", ")}; name the pipeline`, "deal.stage");
+        return rows[0];
     };
-    const decide = (reference, by, reason, confirm) => {
-        const row = rowOf(reference);
-        const ref = `deal:${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 opportunities 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 opportunities SET review = 'rejected', updated_at = ? WHERE id = ?")
-                    .run(now(), Number(row.id));
-            keepDecision("opportunities", Number(row.id), by, reason);
+    const firstStage = (kind, pipeline) => {
+        const pipelines = pipeline === undefined ? pipelineRows(kind) : [{ id: pipeline }];
+        if (pipelines.length !== 1)
+            return refuse(`name the stage: ${pipelines.length === 0 ? `no ${kind} pipeline is stored` : `more than one ${kind} pipeline is stored`}`, "deal.stage");
+        const row = database
+            .prepare("SELECT * FROM pipeline_stages WHERE pipeline_id = ? ORDER BY position, id LIMIT 1")
+            .get(Number(pipelines[0]?.id));
+        return row ?? refuse("the pipeline has no stages", "deal.stage");
+    };
+    const funnelOf = (pipeline, since) => {
+        const kind = pipeline.kind;
+        const cutoff = since === null ? null : Date.parse(`${since}T00:00:00Z`);
+        const items = database
+            .prepare(`SELECT d.id, d.status, d.stage_id FROM ${TABLES[kind]} d JOIN pipeline_stages s ON s.id = d.stage_id ` +
+            "WHERE s.pipeline_id = ? AND d.deleted_at IS NULL AND (? IS NULL OR d.created_at >= ?)")
+            .all(Number(pipeline.id), cutoff, cutoff);
+        const stages = database
+            .prepare("SELECT id, position, outcome FROM pipeline_stages WHERE pipeline_id = ? ORDER BY position, id")
+            .all(Number(pipeline.id));
+        const order = new Map(stages.map((stage, at) => [Number(stage.id), at]));
+        const lostStage = new Set(stages.filter((stage) => stage.outcome === "lost").map((stage) => Number(stage.id)));
+        const entered = new Map();
+        for (const change of database
+            .prepare("SELECT item_id, to_stage_id FROM pipeline_stage_changes WHERE item_type = ? AND pipeline_id = ?")
+            .all(kind, Number(pipeline.id))) {
+            const list = entered.get(Number(change.item_id)) ?? [];
+            list.push(Number(change.to_stage_id));
+            entered.set(Number(change.item_id), list);
+        }
+        const furthest = items.map((item) => {
+            if (item.status === "won")
+                return Number.POSITIVE_INFINITY;
+            const reached = [...(entered.get(Number(item.id)) ?? []), Number(item.stage_id)]
+                .filter((stage) => !lostStage.has(stage))
+                .map((stage) => order.get(stage) ?? -1);
+            return Math.max(-1, ...reached);
         });
-        return dealOf(rowOf(ref));
+        const lost = items.filter((item) => item.status === "lost").length;
+        const reachedAt = (at) => lostStage.has(Number(stages[at]?.id)) ? lost : furthest.filter((far) => far >= at).length;
+        const funnel = pipeline.stages.map((stage, at) => {
+            const reached = reachedAt(at);
+            const next = stages.findIndex((one, after) => after > at && !lostStage.has(Number(one.id)));
+            const conversion = lostStage.has(Number(stages[at]?.id)) || next === -1 || reached === 0
+                ? null
+                : Math.round((reachedAt(next) / reached) * 1000) / 1000;
+            return { ...stage, reached, conversion };
+        });
+        const won = items.filter((item) => item.status === "won").length;
+        return {
+            ...pipeline,
+            stages: funnel,
+            totals: {
+                items: items.length,
+                open: items.length - won - lost,
+                won,
+                lost,
+                winRate: won + lost === 0 ? null : Math.round((won / (won + lost)) * 1000) / 1000,
+            },
+            since,
+        };
+    };
+    /** Sets the stage and, from its outcome, the status; a stage that ends the row closes it today. */
+    const setStage = (kind, id, stage, status, date) => {
+        database
+            .prepare(`UPDATE ${TABLES[kind]} SET stage_id = ?, status = ?, closed_date = ?, updated_at = ? WHERE id = ?`)
+            .run(Number(stage.id), status, status === "open" ? null : date, now(), id);
+    };
+    const notDeleted = (row, kind, what) => {
+        if (row.deleted_at != null)
+            refuse(`${kind}:${row.id} is deleted; it no longer ${what}`, "deal.closed");
     };
     return {
-        addPipeline: ({ name, stages, by }) => {
-            ownerOnly(by, "makes a pipeline");
+        addPipeline: ({ name, kind, stages, by }) => {
+            const pipelineKind = kindOf(kind);
             const named = text(name, "a pipeline's name", 80) ?? refuse("a pipeline needs a name", "pipeline.field");
             if (!Array.isArray(stages) || stages.length === 0 || stages.length > MAX_STAGES)
                 refuse(`a pipeline has 1–${MAX_STAGES} stages`, "pipeline.field");
-            const kept = stages.map((stage) => text(stage, "a stage's name", 80));
-            if (new Set(kept.map(fold)).size !== kept.length)
+            const kept = stages.map((stage) => {
+                const one = typeof stage === "string" ? { name: stage } : stage;
+                return {
+                    name: text(one.name, "a stage's name", 80),
+                    outcome: one.outcome === undefined ? "open" : oneOf(one.outcome, STAGE_OUTCOMES, "a stage's outcome"),
+                };
+            });
+            if (new Set(kept.map((stage) => fold(stage.name))).size !== kept.length)
                 refuse("each stage is named once", "pipeline.field");
-            write(database, () => {
-                if (database.prepare("SELECT 1 FROM pipelines WHERE name_folded = ?").get(fold(named)))
-                    refuse(`a pipeline named ${named} is already stored`, "pipeline.duplicate");
+            authorActor(context, by);
+            const id = write(database, () => {
+                if (database
+                    .prepare("SELECT 1 FROM pipelines WHERE name_folded = ? AND kind = ? AND account_id IS NULL")
+                    .get(fold(named), pipelineKind))
+                    refuse(`a ${pipelineKind} pipeline named ${named} is already stored`, "pipeline.duplicate");
                 const at = now();
-                const id = database
-                    .prepare("INSERT INTO pipelines (name, name_folded, created_at, updated_at) VALUES (?, ?, ?, ?) RETURNING id")
-                    .get(named, fold(named), at, at)?.id;
-                const insert = database.prepare("INSERT INTO pipeline_stages (pipeline_id, name, name_folded, position, created_at, updated_at) " +
-                    "VALUES (?, ?, ?, ?, ?, ?)");
-                kept.forEach((stage, at_) => {
-                    insert.run(Number(id), stage, fold(stage), at_ + 1, at, at);
+                const made = Number(database
+                    .prepare("INSERT INTO pipelines (kind, name, name_folded, created_at, updated_at) VALUES (?, ?, ?, ?, ?) RETURNING id")
+                    .get(pipelineKind, named, fold(named), at, at)?.id);
+                const insert = database.prepare("INSERT INTO pipeline_stages (pipeline_id, name, name_folded, position, outcome, created_at, updated_at) " +
+                    "VALUES (?, ?, ?, ?, ?, ?, ?)");
+                kept.forEach((stage, index) => {
+                    insert.run(made, stage.name, fold(stage.name), index + 1, stage.outcome, at, at);
                 });
+                return made;
             });
-            return pipelinesOf().find((pipeline) => fold(pipeline.name) === fold(named));
+            return pipelinesOf(pipelineRows(pipelineKind).filter((row) => Number(row.id) === id))[0];
+        },
+        pipelines: (filter = {}) => pipelinesOf(pipelineRows(filter.kind === undefined ? undefined : kindOf(filter.kind))),
+        pipeline: (reference, options = {}) => {
+            const kind = options.kind === undefined ? undefined : kindOf(options.kind);
+            const since = isoDate(options.since, "the first day counted");
+            return funnelOf(pipelinesOf([pipelineRow(reference, kind)])[0], since);
         },
-        pipelines: () => pipelinesOf(),
         add: (input) => {
-            const title = text(input.title, "a deal's title", 200) ?? refuse("a deal needs a title", "deal.field");
-            const stageText = text(input.stage, "a stage's name", 80) ?? refuse("a deal starts in a stage", "deal.field");
+            const kind = kindOf(input.kind);
+            const title = text(input.title, `a ${kind}'s title`, 200) ?? refuse(`a ${kind} needs a title`, "deal.field");
             if ((input.amount === undefined) !== (input.currency === undefined))
-                refuse("a deal's amount and currency come together", "deal.field");
+                refuse("an amount and its currency come together", "deal.field");
             const currency = input.currency === undefined ? null : currencyOf(input.currency);
-            const amount = currency === null ? null : minorUnits(input.amount, currency, "a deal's amount");
+            const amount = currency === null ? null : minorUnits(input.amount, currency, "an amount");
             if (amount !== null && amount < 0)
-                refuse("a deal's amount is 0 or more", "money.amount");
-            const closeDate = isoDate(input.closeDate, "a deal's close date");
+                refuse("an amount is 0 or more", "money.amount");
+            const closeDate = isoDate(input.closeDate, "an expected close day");
             const people = input.people ?? [];
             if (people.length > MAX_PEOPLE)
-                refuse(`a deal names at most ${MAX_PEOPLE} people`, "deal.field");
+                refuse(`at most ${MAX_PEOPLE} people`, "deal.field");
+            const owner = input.by === "owner";
+            const source = owner ? "owner" : (text(input.source, "a source", 80) ?? "agent");
+            const reason = text(input.reason, "a reason", 2000);
+            const evidence = input.evidence ?? [];
+            if (!Array.isArray(evidence) || evidence.length > 8)
+                refuse("evidence is at most 8 references", "deal.field");
             const id = write(database, () => {
-                const stage = stageNamed(stageText, input.pipeline);
+                const pipeline = input.pipeline === undefined ? undefined : Number(pipelineRow(input.pipeline, kind).id);
+                const stageText = text(input.stage, "a stage's name", 80);
+                const stage = stageText === null
+                    ? kind === "lead"
+                        ? firstStage(kind, pipeline)
+                        : refuse("a deal starts in a stage", "deal.field")
+                    : stageRow(stageText, kind, pipeline);
+                const status = stage.outcome ?? "open";
                 const organization = partyThing(input.organization, "the organization");
                 if (organization !== undefined && organization.type !== "organization")
                     refuse(`the organization is an organization: reference, not ${input.organization}`, "deal.field");
@@ -182,83 +298,106 @@ export const dealOperationsOver = (context) => {
                     const thing = requiredThing(database, person, "the person");
                     if (thing.type !== "person")
                         return refuse(`${person} is not a person`, "deal.field");
-                    return { id: thing.id, role: oneOf(role, DEAL_ROLES, "a person's role on a deal") };
+                    return { id: thing.id, role: oneOf(role, DEAL_ROLES, "a person's role") };
                 });
-                const by = written(input);
+                const { actor, model } = authorActor(context, input.by);
                 const at = now();
                 const made = Number(database
-                    .prepare("INSERT INTO opportunities (title, organization_id, project_id, stage_id, status, currency, amount, " +
-                    "close_date, review, author_type, author_id, model, confirmed_by_type, confirmed_by_id, source, metadata, " +
-                    "created_at, updated_at) VALUES (?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
-                    .get(title, organization?.id ?? null, by.project, stage, currency, amount, closeDate, by.review, by.actor.type, by.actor.id, by.model, by.confirmedType, by.confirmedId, by.source, by.metadata, at, at)?.id);
+                    .prepare(`INSERT INTO ${TABLES[kind]} (title, organization_id, project_id, stage_id, status, currency, amount, ` +
+                    "close_date, closed_date, author_type, author_id, model, source, metadata, created_at, updated_at) " +
+                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
+                    .get(title, organization?.id ?? null, input.project === undefined ? null : projectId(database, input.project), Number(stage.id), status, currency, amount, closeDate, status === "open" ? null : today(), actor.type, actor.id, model, source, reason === null ? null : JSON.stringify({ reason }), at, at)?.id);
                 const link = database.prepare("INSERT INTO links (from_type, from_id, to_type, to_id, kind, role, source, confirmed, created_at, author, " +
-                    `updated_at) VALUES ('deal', ?, 'person', ?, ${linkKind("related-to")}, ?, ?, 1, ?, ?, ?)`);
+                    `updated_at) VALUES (?, ?, 'person', ?, ${linkKind("related-to")}, ?, ?, 1, ?, ?, ?)`);
                 for (const person of persons)
-                    link.run(made, person.id, person.role, by.owner ? "owner" : "suggested", at, by.owner ? "owner" : "agent", at);
-                keepEvidence("deal", made, by);
+                    link.run(kind, made, person.id, person.role, owner ? "owner" : "suggested", at, owner ? "owner" : "agent", at);
+                if (evidence.length)
+                    linkEvidence(context, { type: kind, id: made }, evidence, owner ? "owner" : "agent");
                 return made;
             });
-            return dealOf(rowOf(`deal:${id}`));
+            return read(`${kind}:${id}`);
         },
-        get: (reference) => dealOf(rowOf(reference)),
+        get: (reference) => read(reference),
         list: (filter = {}) => {
+            const kind = kindOf(filter.kind);
             const project = filter.project === undefined ? null : projectId(database, filter.project);
             const organization = partyThing(filter.organization, "the organization");
             const by = proposedBySql("d.author_type", "d.author_id", filter.proposedBy);
-            const status = filter.status === undefined ? null : oneOf(filter.status, DEAL_STATUSES, "a deal's status");
-            const review = filter.review === undefined ? null : oneOf(filter.review, FINANCE_REVIEWS, "a review");
+            const status = filter.status === undefined ? null : oneOf(filter.status, DEAL_STATUSES, "a status");
             const stage = filter.stage === undefined ? null : fold(filter.stage.trim());
-            const pipeline = filter.pipeline === undefined ? null : fold(filter.pipeline.trim());
+            const pipeline = filter.pipeline === undefined ? null : Number(pipelineRow(filter.pipeline, kind).id);
             const limit = Math.min(Math.max(filter.limit ?? 100, 1), 500);
             return database
-                .prepare(`${DEALS} WHERE d.deleted_at IS NULL AND (? IS NULL OR d.status = ?) AND (? IS NULL OR d.review = ?) ` +
-                "AND (? IS NULL OR d.project_id = ?) AND (? IS NULL OR s.name_folded = ?) AND (? IS NULL OR p.name_folded = ?) " +
+                .prepare(`${itemsSql(kind)} WHERE d.deleted_at IS NULL AND (? IS NULL OR d.status = ?) ` +
+                "AND (? IS NULL OR d.project_id = ?) AND (? IS NULL OR s.name_folded = ?) AND (? IS NULL OR p.id = ?) " +
                 `AND (? IS NULL OR d.organization_id = ?) AND ${by.sql} ORDER BY d.created_at DESC, d.id DESC LIMIT ?`)
-                .all(status, status, review, review, project, project, stage, stage, pipeline, pipeline, organization?.id ?? null, organization?.id ?? null, ...by.params, limit)
-                .map(dealOf);
+                .all(status, status, project, project, stage, stage, pipeline, pipeline, organization?.id ?? null, organization?.id ?? null, ...by.params, limit)
+                .map(itemOf(kind));
+        },
+        find: ({ words, anyWord, accounts, limit }) => {
+            const wanted = [...new Set(words.map((word) => fold(word).trim()).filter(Boolean))];
+            if (!wanted.length)
+                return [];
+            const most = Math.min(Math.max(limit ?? 100, 1), 500);
+            const within = accounts?.map(({ provider, account }) => `${provider}\u0000${account}`);
+            // Titles are short and a CRM holds thousands, not millions: folding them here is cheaper than a word index.
+            const found = DEAL_KINDS.flatMap((kind) => database
+                .prepare(`SELECT d.id, d.title, d.updated_at, a.provider, a.external_id AS account FROM ${TABLES[kind]} d ` +
+                "LEFT JOIN accounts a ON a.id = d.account_id WHERE d.deleted_at IS NULL")
+                .all()
+                .filter((row) => within === undefined || within.includes(`${row.provider}\u0000${row.account}`))
+                .map((row) => {
+                const title = fold(String(row.title));
+                return { kind, row, score: wanted.filter((word) => title.includes(word)).length };
+            })
+                .filter(({ score }) => (anyWord ? score > 0 : score === wanted.length)));
+            return found
+                .sort((a, b) => b.score - a.score ||
+                Number(b.row.updated_at) - Number(a.row.updated_at) ||
+                Number(b.row.id) - Number(a.row.id))
+                .slice(0, most)
+                .map(({ kind, row }) => read(`${kind}:${row.id}`));
         },
         move: (reference, { stage, by }) => {
-            ownerOnly(by, "moves a deal");
-            const row = rowOf(reference);
-            stillOpen(row, "moves");
-            const next = stageNamed(text(stage, "a stage's name", 80) ?? "", Number(row.pipeline_id));
-            write(database, () => {
-                database
-                    .prepare("UPDATE opportunities SET stage_id = ?, updated_at = ? WHERE id = ?")
-                    .run(next, now(), Number(row.id));
-            });
-            return dealOf(rowOf(`deal:${row.id}`));
+            authorActor(context, by);
+            const { kind, row } = rowOf(reference);
+            notDeleted(row, kind, "moves");
+            const next = stageRow(text(stage, "a stage's name", 80) ?? "", kind, Number(row.pipeline_id));
+            write(database, () => setStage(kind, Number(row.id), next, next.outcome, today()));
+            return read(`${kind}:${row.id}`);
         },
         close: (reference, { status, date, reason, by }) => {
-            ownerOnly(by, "closes a deal");
-            const outcome = oneOf(status, ["won", "lost"], "a closed deal's status");
-            const day = isoDate(date, "the day a deal closed") ?? new Date(now()).toISOString().slice(0, 10);
-            const why = text(reason, "why a deal closed", 2000);
-            const row = rowOf(reference);
-            stillOpen(row, "closes");
+            authorActor(context, by);
+            const outcome = oneOf(status, ["won", "lost"], "a closed status");
+            const day = isoDate(date, "the day it closed") ?? today();
+            const why = text(reason, "why it closed", 2000);
+            const { kind, row } = rowOf(reference);
+            notDeleted(row, kind, "closes");
+            const stage = database
+                .prepare("SELECT * FROM pipeline_stages WHERE pipeline_id = ? AND outcome = ? ORDER BY position, id LIMIT 1")
+                .get(Number(row.pipeline_id), outcome) ?? { id: row.stage_id };
             write(database, () => {
-                database
-                    .prepare("UPDATE opportunities SET status = ?, closed_date = ?, updated_at = ?, metadata = CASE WHEN ? IS NULL " +
-                    "THEN metadata ELSE json_set(coalesce(metadata, '{}'), '$.closed_reason', ?) END WHERE id = ?")
-                    .run(outcome, day, now(), why, why, Number(row.id));
+                setStage(kind, Number(row.id), stage, outcome, day);
+                if (why !== null)
+                    database
+                        .prepare(`UPDATE ${TABLES[kind]} SET metadata = json_set(coalesce(metadata, '{}'), '$.closed_reason', ?) WHERE id = ?`)
+                        .run(why, Number(row.id));
             });
-            return dealOf(rowOf(`deal:${row.id}`));
+            return read(`${kind}:${row.id}`);
         },
-        confirm: (reference, by, reason) => decide(reference, by, reason, true),
-        reject: (reference, by, reason) => decide(reference, by, reason, false),
     };
 };
 export const dealsStoreOver = (context) => {
     const operations = dealOperationsOver(context);
     return {
         addPipeline: async (input) => operations.addPipeline(input),
-        pipelines: async () => operations.pipelines(),
+        pipelines: async (filter) => operations.pipelines(filter),
+        pipeline: async (reference, options) => operations.pipeline(reference, options),
         add: async (input) => operations.add(input),
         get: async (reference) => operations.get(reference),
         list: async (filter) => operations.list(filter),
+        find: async (search) => operations.find(search),
         move: async (reference, input) => operations.move(reference, input),
         close: async (reference, input) => operations.close(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/entity-types.d.ts

@@ -10,7 +10,7 @@ export declare const ENTITY_TABLES: {
     readonly calendar_entry: "calendar_entries";
     readonly chat: "chats";
     readonly conversation: "conversations";
-    readonly deal: "opportunities";
+    readonly deal: "deals";
     readonly document: "documents";
     readonly document_picture: "documents";
     readonly email: "emails";
@@ -22,6 +22,7 @@ export declare const ENTITY_TABLES: {
     readonly identity: "identities";
     readonly image: "attachments";
     readonly invoice: "invoices";
+    readonly lead: "leads";
     readonly meeting: "meetings";
     readonly meeting_transcript: "meeting_transcripts";
     readonly meeting_transcript_row: "meeting_transcript_rows";
@@ -32,6 +33,7 @@ export declare const ENTITY_TABLES: {
     readonly organization: "organizations";
     readonly payment: "payments";
     readonly person: "persons";
+    readonly pipeline: "pipelines";
     readonly place: "places";
     readonly project: "projects";
     readonly tag: "canonical_tags";

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

@@ -9,7 +9,7 @@ export const ENTITY_TABLES = {
     calendar_entry: "calendar_entries",
     chat: "chats",
     conversation: "conversations",
-    deal: "opportunities",
+    deal: "deals",
     document: "documents",
     document_picture: "documents",
     email: "emails",
@@ -21,6 +21,7 @@ export const ENTITY_TABLES = {
     identity: "identities",
     image: "attachments",
     invoice: "invoices",
+    lead: "leads",
     meeting: "meetings",
     meeting_transcript: "meeting_transcripts",
     meeting_transcript_row: "meeting_transcript_rows",
@@ -31,6 +32,7 @@ export const ENTITY_TABLES = {
     organization: "organizations",
     payment: "payments",
     person: "persons",
+    pipeline: "pipelines",
     place: "places",
     project: "projects",
     tag: "canonical_tags",