@synap-core/workspace-templates 0.12.0 → 0.23.0

package/src/business-developer.template.test.ts

@@ -1,351 +0,0 @@
-/**
- * Contract tests for the Business Developer CRM overlay.
- *
- * The catalog intentionally reads `templates.ts`, the generated source
- * consumed by every template installer.
- */
-
-import { describe, expect, it } from "vitest";
-import { toWorkspaceDefinition } from "./define.js";
-import { getWorkspaceTemplate } from "./templates.js";
-
-const template = (() => {
-  const resolved = getWorkspaceTemplate("business-developer");
-  if (!resolved) throw new Error("Business Developer template is not registered");
-  return resolved;
-})();
-
-const crmTemplate = (() => {
-  const resolved = getWorkspaceTemplate("crm");
-  if (!resolved) throw new Error("CRM template is not registered");
-  return resolved;
-})();
-
-function profile(slug: string) {
-  const found = template?.profiles.find((candidate) => candidate.slug === slug);
-  expect(found, `expected ${slug} profile`).toBeDefined();
-  if (!found) throw new Error(`expected ${slug} profile`);
-  return found;
-}
-
-function propertySlugs(slug: string) {
-  return new Set(profile(slug).properties.map((property) => property.slug));
-}
-
-describe("Business Developer workspace overlay", () => {
-  it("composes onto CRM without replacing its workspace identity", () => {
-    expect(template).toBeDefined();
-    expect(template.dependencies).toEqual([
-    {
-      slug: "crm",
-      kind: "workspace",
-      relation: "compose",
-      reason: "Adds a lead-first business-development workflow to your CRM workspace.",
-    },
-    ]);
-    expect(template.workspace.subtype).toBe("crm");
-    expect(template.workspace.visibility).toBeUndefined();
-  });
-
-  it("extends the SHARED lead/client roles instead of forking them", () => {
-    // The lifecycle roles are the pod-wide foundation SSOT, re-declared so this
-    // workspace receives the grant. Row-level fields must match foundation
-    // VERBATIM (one row, no overlay mechanism — shared-role-ssot rule (c)); the
-    // business-development fields ride along as workspace-overlay PROPERTIES.
-    for (const slug of ["lead", "client"]) {
-      const facet = profile(slug);
-      expect(facet.scope).toBe("shared");
-      expect(facet.profileKind).toBe("role");
-      expect(facet.applicableKinds).toEqual(["company", "person"]);
-      expect(facet.semanticSlug).toBeUndefined();
-    }
-
-    // The forked spellings are GONE — reintroducing either is the regression.
-    expect(
-      template.profiles.some((candidate) => ["crm-lead", "crm-client"].includes(candidate.slug)),
-    ).toBe(false);
-
-    // Extras only: foundation's own `leadStage` / `clientStatus` / `notes` are
-    // NOT restated here (restating with a different definition is base drift).
-    expect([...propertySlugs("lead")]).not.toContain("leadStage");
-    expect([...propertySlugs("client")]).not.toContain("clientStatus");
-
-    expect([...propertySlugs("lead")].sort()).toEqual([
-    "assignedUserId",
-    "convertedAt",
-    "disqualificationReason",
-    "icpScore",
-    "lastContactedAt",
-    "lifecycleStage",
-    "nextAction",
-    "nextActionAt",
-    "outreachChannels",
-    "qualificationNotes",
-    "source",
-    ].sort());
-
-    expect([...propertySlugs("client")].sort()).toEqual([
-      "becameClientAt",
-      "handoffDestination",
-      "handoffNotes",
-      "handoffStatus",
-    ].sort());
-  });
-
-  it("models proposals and auditable commission separately from leads", () => {
-    const commercialStages = profile("deal")
-      .properties.find((property) => property.slug === "commercialStage")?.enumValues;
-    expect(commercialStages).toEqual(["draft", "proposed", "negotiating", "won", "lost"]);
-
-    expect([...propertySlugs("crm-commission-entitlement")].sort()).toEqual([
-    "earnedAt",
-    "estimatedAmount",
-    "feeBasisAmount",
-    "paidAt",
-    "rateBps",
-    "sequence",
-    "sourceDealId",
-    "sourcedByUserId",
-    "status",
-    "voidReason",
-    ].sort());
-
-    expect([...propertySlugs("deal")].sort()).toEqual([
-      "commercialStage",
-      "commissionEntitlementId",
-      "commissionStatus",
-      "expectedClientGain",
-      "lostReason",
-      "sourcedByUserId",
-      "synapFeeAmount",
-      "synapFeeModel",
-      "synapFixedFee",
-      "synapSuccessFeeRate",
-      "wonAt",
-    ].sort());
-
-    const entitlementId = profile("deal").properties.find(
-      (property) => property.slug === "commissionEntitlementId",
-    );
-    expect(entitlementId).toMatchObject({
-      valueType: "entity_id",
-      inputType: "entity_select",
-      targetProfileSlug: "crm-commission-entitlement",
-    });
-    expect(
-      profile("crm-commission-entitlement").properties.find(
-        (property) => property.slug === "sourceDealId",
-      ),
-    ).toMatchObject({
-      valueType: "entity_id",
-      inputType: "entity_select",
-      targetProfileSlug: "deal",
-    });
-
-    expect(
-      template.entityLinks?.map(({ sourceProfileSlug, targetProfileSlug, type }) => ({
-        sourceProfileSlug,
-        targetProfileSlug,
-        type,
-      })),
-    ).toEqual([
-      { sourceProfileSlug: "deal", targetProfileSlug: "crm-commission-entitlement", type: "crm_commission_for_deal" },
-      { sourceProfileSlug: "person", targetProfileSlug: "campaign", type: "member_of" },
-      { sourceProfileSlug: "company", targetProfileSlug: "campaign", type: "member_of" },
-    ]);
-  });
-
-  it("relies on CRM's single generic counterparty relationship", () => {
-    // `linked_to_deal` stays the ONE generic counterparty edge the handoff
-    // flow's `find-party` node reads. The role-qualified edges beside it are
-    // ADDITIVE (a brokered deal has a client side and a partner side) and must
-    // never displace it — hence the exact-order assertion.
-    expect(
-      crmTemplate.entityLinks?.map(({ sourceProfileSlug, targetProfileSlug, type }) => ({
-        sourceProfileSlug,
-        targetProfileSlug,
-        type,
-      })),
-    ).toEqual([
-      { sourceProfileSlug: "person", targetProfileSlug: "deal", type: "linked_to_deal" },
-      { sourceProfileSlug: "company", targetProfileSlug: "deal", type: "linked_to_deal" },
-      { sourceProfileSlug: "person", targetProfileSlug: "deal", type: "client_on_deal" },
-      { sourceProfileSlug: "company", targetProfileSlug: "deal", type: "client_on_deal" },
-      { sourceProfileSlug: "person", targetProfileSlug: "deal", type: "partner_on_deal" },
-      { sourceProfileSlug: "company", targetProfileSlug: "deal", type: "partner_on_deal" },
-    ]);
-
-    // The handoff still reads ONLY the generic edge — a brokered deal's partner
-    // side must not be mistaken for the counterparty that becomes the client.
-    const handoff = template.automations?.find((a) => a.name === "Win and hand off");
-    const findParty = (handoff?.flow.nodes as Array<{ id?: string; data?: unknown }>).find(
-      (n) => n.id === "find-party",
-    );
-    expect((findParty?.data as { relationTypes?: string[] }).relationTypes).toEqual([
-      "linked_to_deal",
-    ]);
-  });
-
-  it("keeps playbooks lead-first and proposal-gated", () => {
-    expect(
-      template.playbooks?.map(({ name, subjectProfile }) => ({ name, profileSlug: subjectProfile?.profileSlug })),
-    ).toEqual([
-      { name: "Qualify a CRM lead", profileSlug: "lead" },
-      { name: "Advance a commercial proposal", profileSlug: "deal" },
-    ]);
-    expect(template.playbooks?.[0]?.goalTemplate ?? "").toMatch(/Do not create a deal/);
-    expect(template.playbooks?.[1]?.goalTemplate ?? "").toMatch(/Never mark the counterparty as a CRM client/);
-  });
-
-  it("declares the complete, human-confirmed handoff as a reusable flow", () => {
-    const handoff = template.automations?.find(
-      (automation) => automation.name === "Win and hand off",
-    );
-    expect(handoff).toMatchObject({
-      key: "crm-win-and-handoff",
-      triggerType: "manual",
-      status: "active",
-    });
-    expect(handoff?.flow.nodes).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ id: "read-deal", type: "entity_read" }),
-        expect.objectContaining({ id: "find-party", type: "related_entities" }),
-        expect.objectContaining({ id: "guard-lead", type: "guard" }),
-        expect.objectContaining({ id: "commission-sequence", type: "select" }),
-        expect.objectContaining({ id: "claim-first-client-deal", type: "claim" }),
-        expect.objectContaining({ id: "claim-commission-entitlement", type: "claim" }),
-        expect.objectContaining({ id: "prior-won-deals", type: "related_entities" }),
-        expect.objectContaining({
-          id: "is-first-client-deal",
-          type: "compute",
-          data: expect.objectContaining({
-            left: "{{steps.claim-first-client-deal.output.claimed}}",
-            right: "{{steps.has-no-prior-won-deals.output.result}}",
-          }),
-        }),
-        expect.objectContaining({ id: "create-commission", type: "output" }),
-        expect.objectContaining({ id: "convert-lead", type: "output" }),
-      ]),
-    );
-    expect(handoff?.flow.nodes).toContainEqual(
-      expect.objectContaining({
-        id: "create-commission",
-        data: expect.objectContaining({
-          outputType: "entity_create",
-          config: expect.objectContaining({ dedupeBy: "sourceDealId" }),
-        }),
-      }),
-    );
-    expect(handoff?.flow.nodes).toContainEqual(
-      expect.objectContaining({
-        id: "guard-deal",
-        data: expect.objectContaining({
-          checks: expect.arrayContaining([
-            expect.objectContaining({
-              path: "steps.read-deal.output.entity.properties.commercialStage",
-              anyOf: expect.arrayContaining([
-                expect.objectContaining({ path: "steps.read-deal.output.entity.properties.commercialStage", equals: "won" }),
-                expect.objectContaining({ path: "steps.read-deal.output.entity.properties.dealStage", equals: "won" }),
-              ]),
-            }),
-          ]),
-        }),
-      }),
-    );
-
-    // The handoff writes the SHARED role slugs — this is what makes the party
-    // a client pod-wide (and therefore visible to the Operations pickup).
-    expect(handoff?.flow.nodes).toContainEqual(
-      expect.objectContaining({
-        id: "attach-client",
-        data: expect.objectContaining({
-          outputType: "facet_attach",
-          config: expect.objectContaining({ facetSlug: "client" }),
-        }),
-      }),
-    );
-    expect(handoff?.flow.nodes).toContainEqual(
-      expect.objectContaining({
-        id: "convert-lead",
-        data: expect.objectContaining({
-          outputType: "facet_update",
-          config: expect.objectContaining({ facetSlug: "lead" }),
-        }),
-      }),
-    );
-    expect(handoff?.flow.nodes).toContainEqual(
-      expect.objectContaining({
-        id: "guard-lead",
-        data: expect.objectContaining({
-          checks: expect.arrayContaining([
-            expect.objectContaining({ arrayIncludes: "lead" }),
-          ]),
-        }),
-      }),
-    );
-
-    expect(template.actionPlacements).toEqual([
-      expect.objectContaining({
-        profileSlug: "person",
-        kind: "playbook",
-        ref: "Qualify a CRM lead",
-        when: { requiredFacetSlugs: ["lead"] },
-      }),
-      expect.objectContaining({
-        profileSlug: "company",
-        kind: "playbook",
-        ref: "Qualify a CRM lead",
-        when: { requiredFacetSlugs: ["lead"] },
-      }),
-      expect.objectContaining({
-        profileSlug: "deal",
-        kind: "playbook",
-        ref: "Advance a commercial proposal",
-      }),
-      expect.objectContaining({
-        profileSlug: "deal",
-        kind: "automation",
-        ref: "Win and hand off",
-        label: "Hand off won proposal",
-        when: {
-          propertyAnyEquals: { commercialStage: ["won"], dealStage: ["won"] },
-          propertyNotEquals: { handoffStatus: "handed_off" },
-        },
-        confirmation: expect.objectContaining({
-          confirmLabel: "Hand off proposal",
-        }),
-      }),
-    ]);
-  });
-
-  it("carries playbooks through the workspace-create converter", () => {
-    const { definition } = toWorkspaceDefinition("business-developer");
-    const playbooks = definition.playbooks ?? [];
-
-    expect(playbooks).toHaveLength(2);
-    expect(playbooks[0]).toMatchObject({
-      name: "Qualify a CRM lead",
-      subjectProfile: { profileSlug: "lead" },
-      params: [{ name: "lead", type: "string", description: "CRM lead" }],
-    });
-    expect(playbooks[1]).toMatchObject({
-      name: "Advance a commercial proposal",
-      subjectProfile: { profileSlug: "deal" },
-      params: [{ name: "deal", type: "string", description: "Commercial proposal" }],
-    });
-
-    expect(definition.flowAutomations).toHaveLength(1);
-    expect(definition.flowAutomations?.[0]).toMatchObject({
-      key: "crm-win-and-handoff",
-      name: "Win and hand off",
-      triggerType: "manual",
-      flowDefinition: expect.objectContaining({
-        nodes: expect.arrayContaining([
-          expect.objectContaining({ id: "read-deal", type: "entity_read" }),
-          expect.objectContaining({ id: "commission-sequence", type: "select" }),
-          expect.objectContaining({ id: "claim-first-client-deal", type: "claim" }),
-        ]),
-      }),
-    });
-  });
-});