@wirecat/cli-core 0.584.0 → 0.586.0

package/dist/store/sqlite/deals.js

@@ -0,0 +1,264 @@
+import { CliError } from "@wirecat/cli-base";
+import { DEAL_ROLES, DEAL_STATUSES, dealLine } from "../../domain/deals.js";
+import { FINANCE_REVIEWS } from "../../domain/finance.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 { isoDate, oneOf, refuse, reviewedRowsOver, text } from "./finance.js";
+import { linkKind } from "./link-kinds.js";
+import { authorActor, projectId } 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 MAX_PEOPLE = 20;
+const ownerOnly = (by, what) => {
+    if (by !== "owner")
+        refuse(`only the owner ${what}`, "deal.owner-only", "permission_error");
+};
+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")} ` +
+        "AND to_type = 'person' AND to_id IS NOT NULL ORDER BY id")
+        .all(id)
+        .map((row) => ({ ...partyOf("person", row.to_id), role: row.role }));
+    const dealOf = (row) => {
+        const currency = row.currency == null ? null : String(row.currency);
+        const amount = row.amount == null || currency === null ? null : Number(row.amount);
+        const fields = {
+            id: Number(row.id),
+            title: String(row.title),
+            stage: String(row.stage_name),
+            amount,
+            currency,
+            status: row.status,
+            review: row.review,
+        };
+        return {
+            id: String(row.id),
+            ref: `deal:${row.id}`,
+            title: fields.title,
+            summary: dealLine(fields),
+            pipeline: String(row.pipeline_name),
+            stage: fields.stage,
+            status: fields.status,
+            organization: partyOf(row.organization_id == null ? null : "organization", row.organization_id),
+            currency,
+            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"),
+        };
+    };
+    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);
+    };
+    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);
+    };
+    /** 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);
+        if (rows.length === 0)
+            return refuse(`no stage named ${stage}${within === null ? "" : " in that pipeline"}`, "deal.stage");
+        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);
+    };
+    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),
+            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(),
+        }));
+    };
+    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");
+    };
+    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);
+        });
+        return dealOf(rowOf(ref));
+    };
+    return {
+        addPipeline: ({ name, stages, by }) => {
+            ownerOnly(by, "makes a pipeline");
+            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)
+                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");
+                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);
+                });
+            });
+            return pipelinesOf().find((pipeline) => fold(pipeline.name) === fold(named));
+        },
+        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");
+            if ((input.amount === undefined) !== (input.currency === undefined))
+                refuse("a deal's amount and 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");
+            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");
+            const people = input.people ?? [];
+            if (people.length > MAX_PEOPLE)
+                refuse(`a deal names at most ${MAX_PEOPLE} people`, "deal.field");
+            const id = write(database, () => {
+                const stage = stageNamed(stageText, input.pipeline);
+                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");
+                const persons = people.map(({ person, role }) => {
+                    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") };
+                });
+                const by = written(input);
+                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);
+                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, ?, ?, ?)`);
+                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);
+                return made;
+            });
+            return dealOf(rowOf(`deal:${id}`));
+        },
+        get: (reference) => dealOf(rowOf(reference)),
+        list: (filter = {}) => {
+            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 stage = filter.stage === undefined ? null : fold(filter.stage.trim());
+            const pipeline = filter.pipeline === undefined ? null : fold(filter.pipeline.trim());
+            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 = ?) " +
+                `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);
+        },
+        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}`));
+        },
+        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");
+            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));
+            });
+            return dealOf(rowOf(`deal:${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(),
+        add: async (input) => operations.add(input),
+        get: async (reference) => operations.get(reference),
+        list: async (filter) => operations.list(filter),
+        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,6 +10,7 @@ export declare const ENTITY_TABLES: {
     readonly calendar_entry: "calendar_entries";
     readonly chat: "chats";
     readonly conversation: "conversations";
+    readonly deal: "opportunities";
     readonly document: "documents";
     readonly document_picture: "documents";
     readonly email: "emails";

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

@@ -9,6 +9,7 @@ export const ENTITY_TABLES = {
     calendar_entry: "calendar_entries",
     chat: "chats",
     conversation: "conversations",
+    deal: "opportunities",
     document: "documents",
     document_picture: "documents",
     email: "emails",

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

@@ -216,7 +216,7 @@ export declare const iso: (value: unknown) => string;
 export declare const reviewedRowsOver: (context: StoreContext) => {
     partyOf: (type: unknown, id: unknown) => Party | null;
     partyThing: (reference: string | undefined, what: string) => import("./things.js").Thing | undefined;
-    reviewedOf: (row: Row, type: "invoice" | "payment" | "order") => Reviewed;
+    reviewedOf: (row: Row, type: "invoice" | "payment" | "order" | "deal") => Reviewed;
     written: (input: Written) => {
         owner: boolean;
         actor: Actor;
@@ -229,7 +229,7 @@ export declare const reviewedRowsOver: (context: StoreContext) => {
         project: number | null;
         evidence: string[];
     };
-    keepEvidence: (type: "invoice" | "payment" | "order", id: number, by: ReturnType<(input: Written) => {
+    keepEvidence: (type: "invoice" | "payment" | "order" | "deal", id: number, by: ReturnType<(input: Written) => {
         owner: boolean;
         actor: Actor;
         model: string | null;
@@ -242,7 +242,7 @@ export declare const reviewedRowsOver: (context: StoreContext) => {
         evidence: string[];
     }>) => void;
     ownerOnly: (by: Author, what: string) => void;
-    keepDecision: (table: "invoices" | "payments" | "orders", id: number, by: Decider, reason?: string) => void;
+    keepDecision: (table: "invoices" | "payments" | "orders" | "opportunities", id: number, by: Decider, reason?: string) => void;
 };
 type FinanceOperations = {
     [K in keyof FinanceStore]: FinanceStore[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R : never;

package/dist/store/sqlite/knowledge.js

@@ -152,7 +152,8 @@ export const knowledgeStoreOver = (context) => {
             parsed.type === "meeting" ||
             parsed.type === "invoice" ||
             parsed.type === "payment" ||
-            parsed.type === "order")
+            parsed.type === "order" ||
+            parsed.type === "deal")
             return undefined;
         return { type: parsed.type, id: parsed.id };
     };

package/dist/store/sqlite/manifest.js

@@ -68,6 +68,8 @@ export const MANIFEST = [
     { name: "20261105125314_version-50-orders", version: 50, minCompatible: 34 },
     { name: "20261105125315_version-50-orders-rules", version: 50, minCompatible: 34 },
     { name: "20261105144549_version-51-task-links", version: 51, minCompatible: 34 },
+    { name: "20261106010504_version-52-deals", version: 52, minCompatible: 34 },
+    { name: "20261106010507_version-52-deals-rules", version: 52, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

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

@@ -984,5 +984,26 @@ export const GENERATED = [
             "ALTER TABLE `tasks` ADD `source_url` text;",
             "CREATE INDEX `tasks_by_provider_external_id` ON `tasks` (`provider`,`external_id`) WHERE external_id IS NOT NULL;"
         ]
+    },
+    {
+        "name": "20261106010504_version-52-deals",
+        "statements": [
+            "CREATE TABLE `opportunities` (\n\t`id` integer PRIMARY KEY,\n\t`title` text NOT NULL,\n\t`organization_id` integer,\n\t`project_id` integer,\n\t`stage_id` integer NOT NULL,\n\t`status` text NOT NULL,\n\t`currency` text,\n\t`amount` integer,\n\t`close_date` text,\n\t`closed_date` text,\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_opportunities_organization_id_organizations_id_fk` FOREIGN KEY (`organization_id`) REFERENCES `organizations`(`id`),\n\tCONSTRAINT `fk_opportunities_project_id_projects_id_fk` FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`),\n\tCONSTRAINT `fk_opportunities_stage_id_pipeline_stages_id_fk` FOREIGN KEY (`stage_id`) REFERENCES `pipeline_stages`(`id`)\n);",
+            "CREATE TABLE `pipeline_stages` (\n\t`id` integer PRIMARY KEY,\n\t`pipeline_id` integer NOT NULL,\n\t`name` text NOT NULL,\n\t`name_folded` text NOT NULL,\n\t`position` integer NOT NULL,\n\t`created_at` integer NOT NULL,\n\t`updated_at` integer NOT NULL,\n\tCONSTRAINT `fk_pipeline_stages_pipeline_id_pipelines_id_fk` FOREIGN KEY (`pipeline_id`) REFERENCES `pipelines`(`id`),\n\tCONSTRAINT `pipeline_stages_pipeline_id_name_folded_unique` UNIQUE(`pipeline_id`,`name_folded`),\n\tCONSTRAINT `pipeline_stages_pipeline_id_position_unique` UNIQUE(`pipeline_id`,`position`)\n);",
+            "CREATE TABLE `pipelines` (\n\t`id` integer PRIMARY KEY,\n\t`name` text NOT NULL,\n\t`name_folded` text NOT NULL UNIQUE,\n\t`created_at` integer NOT NULL,\n\t`updated_at` integer NOT NULL\n);",
+            "CREATE INDEX `opportunities_by_organization_id` ON `opportunities` (`organization_id`);",
+            "CREATE INDEX `opportunities_by_project_id` ON `opportunities` (`project_id`);",
+            "CREATE INDEX `opportunities_by_stage_id` ON `opportunities` (`stage_id`);",
+            "CREATE INDEX `opportunities_by_author_type_author_id` ON `opportunities` (`author_type`,`author_id`);",
+            "CREATE INDEX `opportunities_by_confirmed_by_type_confirmed_by_id` ON `opportunities` (`confirmed_by_type`,`confirmed_by_id`);"
+        ]
+    },
+    {
+        "name": "20261106010507_version-52-deals-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 a deal with an unknown status, or an amount without its currency.\nCREATE TRIGGER opportunities_valid_bi BEFORE INSERT ON opportunities\n  WHEN new.status NOT IN ('open', 'won', 'lost')\n    OR new.review NOT IN ('proposed', 'confirmed', 'rejected')\n    OR (new.amount IS NULL) <> (new.currency IS NULL) OR new.amount < 0 BEGIN\n  SELECT RAISE(ABORT, 'opportunities: a known status and review, an amount with its currency');\nEND;",
+            "CREATE TRIGGER opportunities_valid_bu BEFORE UPDATE ON opportunities\n  WHEN new.status NOT IN ('open', 'won', 'lost')\n    OR new.review NOT IN ('proposed', 'confirmed', 'rejected')\n    OR (new.amount IS NULL) <> (new.currency IS NULL) OR new.amount < 0 BEGIN\n  SELECT RAISE(ABORT, 'opportunities: a known status and review, an amount with its currency');\nEND;",
+            "-- A deal moves between the stages of its own pipeline only.\nCREATE TRIGGER opportunities_same_pipeline_bu BEFORE UPDATE OF stage_id ON opportunities\n  WHEN (SELECT pipeline_id FROM pipeline_stages WHERE id = new.stage_id)\n    <> (SELECT pipeline_id FROM pipeline_stages WHERE id = old.stage_id) BEGIN\n  SELECT RAISE(ABORT, 'opportunities: a deal moves within its own pipeline');\nEND;"
+        ]
     }
 ];

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

@@ -1,3 +1,4 @@
+import { dealLine } from "../../domain/deals.js";
 import { invoiceLine, paymentLine } from "../../domain/finance.js";
 import { orderLine } from "../../domain/orders.js";
 import { filesAccountSql, providerLabel, providerNamed } from "../../domain/providers.js";
@@ -207,6 +208,13 @@ const READERS = {
         at: "x.created_at",
         deleted: "x.deleted_at",
     })),
+    deal: byId("deal", "opportunities", () => ({
+        title: "json_object('id', x.id, 'title', x.title, 'stage', (SELECT name FROM pipeline_stages WHERE id = x.stage_id), " +
+            "'amount', x.amount, '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" };
@@ -314,6 +322,8 @@ const titleOf = (kind, reference, found) => {
             return fieldsOf(found.title, paymentLine);
         case "order":
             return fieldsOf(found.title, orderLine);
+        case "deal":
+            return fieldsOf(found.title, dealLine);
         case "folder":
             return reference.type === "folder" && reference.path !== null && found.title !== null
                 ? `${found.title}/${reference.path}`