create-ailk 0.22.0 → 0.24.0

package/templates/apps/api/src/services/offerings/__tests__/org-products.test.ts

@@ -0,0 +1,400 @@
+/**
+ * services/offerings — the owner's product list and the org-enabled write
+ * (#8922, spec docs/specs/8922-the-may-sell-product-list-spec.md D3, D4):
+ * `listOrgProducts` lists every active product with its enabled flag and
+ * held reason (AC-1), `setOrgEnabledProducts` refuses a held or unknown id
+ * and writes the set through `store.ts` alone (AC-2), a failed read or a
+ * failed response parse writes nothing (AC-4, AC-6), and the owner path
+ * shares the per-minute catalog read (AC-7).
+ *
+ * Every suite runs over `createInMemoryPrisma()` and #8876's seed, with
+ * `@working-theory/stripe-client` mocked so that touching any of its exports
+ * throws.
+ */
+// eslint-disable-next-line no-restricted-syntax -- lib/prisma.ts wraps the external DB boundary (PrismaClient requires a live connection); the in-memory double is the repo-standard where-honouring test double for it.
+jest.mock("../../../lib/prisma.js", () =>
+  jest
+    .requireActual<typeof import("../../../__tests__/factories/in-memory-prisma")>(
+      "../../../__tests__/factories/in-memory-prisma",
+    )
+    .createInMemoryPrisma(),
+);
+
+jest.mock(
+  "@working-theory/stripe-client",
+  () =>
+    new Proxy(
+      {},
+      {
+        get: (_target, key) => {
+          if (key === "__esModule") return true;
+          throw new Error(`@working-theory/stripe-client.${String(key)} was touched`);
+        },
+      },
+    ),
+);
+
+const mockLog = jest.fn();
+jest.mock("@working-theory/observability", () => ({
+  logger: {
+    error: (...args: unknown[]) => mockLog("error", ...args),
+    warn: (...args: unknown[]) => mockLog("warn", ...args),
+    info: (...args: unknown[]) => mockLog("info", ...args),
+    debug: (...args: unknown[]) => mockLog("debug", ...args),
+  },
+}));
+
+import { prisma } from "../../../lib/prisma.js";
+import {
+  OfferingsShapeError,
+  OfferingsSourceError,
+  getOrgEnabledProducts,
+  listOrgProducts,
+  resetOfferingsRefreshStateForTests,
+  setOrgEnabledProducts,
+  type CatalogPrice,
+  type CatalogProduct,
+  type OfferingsSourceFor,
+  type OrgProductEntry,
+} from "../index.js";
+import { writeEnabledProductIds } from "../store.js";
+import {
+  EXPECTED_FIXTURE_OFFERINGS,
+  FIXTURE_NOW,
+  FIXTURE_ORG,
+  FIXTURE_ORG_2,
+  OFFERINGS_FIXTURE_CATALOG,
+  refusingSourceFor,
+  seedOfferings,
+} from "./fixtures.js";
+
+type Row = Record<string, unknown>;
+// The in-memory double exposes its store and recorded delegates, which the
+// PrismaClient type the import carries does not name, so it is named here once.
+// eslint-disable-next-line no-restricted-syntax -- justified above
+const db = prisma as unknown as {
+  __db: Record<string, Row[]>;
+  organizationOfferings: { upsert: jest.Mock };
+};
+
+const SECOND = 1000;
+const at = (offsetMs: number) => new Date(FIXTURE_NOW.getTime() + offsetMs);
+
+const plan = (id: string, name: string, active = true): CatalogProduct => ({
+  id,
+  active,
+  name,
+  description: `${name} description`,
+  marketing_features: [],
+  unit_label: null,
+  metadata: { ailk_group: "plan" },
+});
+const price = (
+  id: string,
+  product: string,
+  lookupKey: string | null,
+  interval: "month" | "year",
+): CatalogPrice => ({
+  id,
+  active: true,
+  product,
+  lookup_key: lookupKey,
+  type: "recurring",
+  recurring: { interval, interval_count: 1, usage_type: "licensed" },
+  billing_scheme: "per_unit",
+  unit_amount: 1000,
+  currency: "usd",
+});
+
+/** #8876's fixture catalog plus the spec §5 additions (an inactive Product, a paging repeat, G3 and G4). */
+const CASE_CATALOG = {
+  products: [
+    ...OFFERINGS_FIXTURE_CATALOG.products,
+    plan("prod_t_inactive", "Retired plan", false),
+    OFFERINGS_FIXTURE_CATALOG.products.find((p) => p.id === "prod_fixture_basic")!,
+    plan("prod_t_conflict_a", "Team A"),
+    plan("prod_t_conflict_b", "Team B"),
+    plan("prod_t_period", "Pro by period"),
+    plan("prod_t_nokey", "No key"),
+  ],
+  prices: [
+    ...OFFERINGS_FIXTURE_CATALOG.prices,
+    price("price_t_inactive", "prod_t_inactive", "retired_monthly", "month"),
+    price("price_t_conflict_a", "prod_t_conflict_a", "team_monthly", "month"),
+    price("price_t_conflict_b", "prod_t_conflict_b", "team_yearly", "year"),
+    price("price_t_period", "prod_t_period", "pro_monthly", "year"),
+    price("price_t_nokey", "prod_t_nokey", null, "month"),
+  ],
+};
+
+/** Every fixture string a log line or an error must never carry. */
+const STRIPE_TEXT = [
+  ...CASE_CATALOG.products.flatMap((p) => [p.id, p.name, p.description] as unknown[]),
+  ...CASE_CATALOG.prices.map((p) => p.id),
+  "Unlimited pages",
+  "Priority support",
+].filter((v): v is string => typeof v === "string" && v.length > 0);
+
+const sellable = (productId: string, enabled: boolean): OrgProductEntry => {
+  const o = EXPECTED_FIXTURE_OFFERINGS.find((x) => x.productId === productId)!;
+  return { productId, name: o.name, description: o.description, enabled, heldReason: null };
+};
+const held = (productId: string, name: string, heldReason: string): OrgProductEntry =>
+  ({ productId, name, description: null, enabled: false, heldReason }) as OrgProductEntry;
+
+/** The list for the case catalog with `enabled` the stored set. */
+function expectedList(enabled: string[]): OrgProductEntry[] {
+  const on = new Set(enabled);
+  return [
+    ...EXPECTED_FIXTURE_OFFERINGS.map((o) => sellable(o.productId, on.has(o.productId))),
+    held("prod_fixture_quarterly", "Pro quarterly", "needs_lookup_key"),
+    held("prod_fixture_legacy", "Legacy retainer", "group_invalid"),
+    held("prod_t_conflict_a", "Team A", "plan_conflict"),
+    held("prod_t_conflict_b", "Team B", "plan_conflict"),
+    held("prod_t_period", "Pro by period", "needs_lookup_key"),
+    held("prod_t_nokey", "No key", "needs_lookup_key"),
+  ];
+}
+
+/** A counting `sourceFor` answering the case catalog, or rejecting with `failWith`. */
+function countingSource(failWith?: unknown) {
+  const asked: string[] = [];
+  let calls = 0;
+  const sourceFor: OfferingsSourceFor = (organizationId) => {
+    asked.push(organizationId);
+    return {
+      listActiveCatalog: async () => {
+        calls += 1;
+        if (failWith !== undefined) throw failWith;
+        return structuredClone(CASE_CATALOG);
+      },
+    };
+  };
+  return { sourceFor, asked, calls: () => calls };
+}
+
+function storedSet(organizationId = FIXTURE_ORG): unknown {
+  return db.__db.organizationOfferings?.find((r) => r.organizationId === organizationId)?.enabledProductIds;
+}
+
+function setStoredSet(ids: string[]): void {
+  const row = db.__db.organizationOfferings!.find((r) => r.organizationId === FIXTURE_ORG)!;
+  row.enabledProductIds = [...ids];
+}
+
+function corruptConnection(): void {
+  db.__db.stripeConnection!.find((r) => r.organizationId === FIXTURE_ORG)!.keyLast4 = "ab";
+}
+
+const noValidate = { validate: () => undefined };
+
+beforeEach(async () => {
+  // With the multi-tenant module and no STRIPE_ENV_ORGANIZATION_ID nobody owns the
+  // environment key (#9285 AC-8), so "no connection" stays no connection here.
+  process.env.AILK_ENABLED_MODULES = "multi-tenant";
+  delete process.env.STRIPE_ENV_ORGANIZATION_ID;
+  for (const key of Object.keys(db.__db)) delete db.__db[key];
+  jest.clearAllMocks();
+  resetOfferingsRefreshStateForTests();
+  await seedOfferings(prisma, { now: FIXTURE_NOW });
+  setStoredSet(["prod_fixture_growth", "prod_fixture_quarterly"]);
+});
+
+afterEach(() => {
+  const text = JSON.stringify(mockLog.mock.calls);
+  for (const s of STRIPE_TEXT) expect(text).not.toContain(s);
+  for (const [, obj] of mockLog.mock.calls as Array<[string, Record<string, unknown>]>) {
+    for (const key of Object.keys(obj)) {
+      expect(["organizationId", "workspaceId", "outcome", "reason", "errName", "dropped", "tool"]).toContain(key);
+    }
+  }
+});
+
+// ─── AC-1 — every active product, its flag and its reason ────────────────────
+
+describe("listOrgProducts (#8922 D3, AC-1)", () => {
+  it("lists every active, distinct product: sellable first, then held, each once", async () => {
+    const src = countingSource();
+    const list = await listOrgProducts(FIXTURE_ORG, src.sourceFor, { now: FIXTURE_NOW });
+    expect(list).toEqual({ connection: "connected", products: expectedList(["prod_fixture_growth"]) });
+    if (list.connection !== "connected") throw new Error("unreachable");
+    const ids = list.products.map((p) => p.productId);
+    expect(ids).not.toContain("prod_t_inactive");
+    expect(ids.filter((id) => id === "prod_fixture_basic")).toHaveLength(1);
+    for (const entry of list.products) {
+      expect(Object.keys(entry).sort()).toEqual(["description", "enabled", "heldReason", "name", "productId"]);
+    }
+    // A held product in the stored set reads off (CL5).
+    expect(list.products.find((p) => p.productId === "prod_fixture_quarterly")!.enabled).toBe(false);
+    expect(JSON.stringify(list)).not.toMatch(/example\.com|price_/);
+    expect(src.calls()).toBe(1);
+  });
+
+  it("answers none with no connection, without building a source", async () => {
+    await expect(listOrgProducts(FIXTURE_ORG_2, refusingSourceFor, { now: FIXTURE_NOW })).resolves.toEqual({
+      connection: "none",
+    });
+  });
+
+  it("answers unreadable for a corrupt connection, never none, without building a source", async () => {
+    corruptConnection();
+    await expect(listOrgProducts(FIXTURE_ORG, refusingSourceFor, { now: FIXTURE_NOW })).resolves.toEqual({
+      connection: "unreadable",
+    });
+  });
+
+  it("turns a source failure into OfferingsSourceError carrying no Stripe text and no cause", async () => {
+    const keyShaped = ["rk", "test", "QzQjVvWwKkXxYyZzQqJjPpBb"].join("_");
+    const src = countingSource(new Error(`Invalid API Key provided: ${keyShaped}`));
+    const err = await listOrgProducts(FIXTURE_ORG, src.sourceFor, { now: FIXTURE_NOW }).catch((e: unknown) => e);
+    expect(err).toBeInstanceOf(OfferingsSourceError);
+    expect(JSON.stringify(Object.entries(err as object))).not.toContain(keyShaped);
+    expect((err as Error).message).not.toContain(keyShaped);
+    expect((err as { cause?: unknown }).cause).toBeUndefined();
+    expect(mockLog).toHaveBeenCalledWith(
+      "warn",
+      { organizationId: FIXTURE_ORG, outcome: "source_failed", errName: "Error" },
+      expect.any(String),
+    );
+  });
+});
+
+// ─── AC-2 — the write, through store.ts only ────────────────────────────────
+
+describe("setOrgEnabledProducts (#8922 D3, D4, AC-2)", () => {
+  it("writes the set, answers the previous set and the list for the new set", async () => {
+    const src = countingSource();
+    const ids = ["prod_fixture_basic", "prod_fixture_seo_audit"];
+    const result = await setOrgEnabledProducts(FIXTURE_ORG, ids, src.sourceFor, { now: FIXTURE_NOW, ...noValidate });
+    expect(result).toEqual({
+      kind: "written",
+      previous: ["prod_fixture_growth", "prod_fixture_quarterly"],
+      list: { connection: "connected", products: expectedList(ids) },
+    });
+    expect(storedSet()).toEqual(ids);
+    expect(db.organizationOfferings.upsert).toHaveBeenCalledTimes(1);
+
+    // Read back from the row, with no further Stripe call (CL4).
+    const read = await getOrgEnabledProducts(FIXTURE_ORG, src.sourceFor, { now: at(30 * SECOND) });
+    expect(read!.productIds).toEqual(ids);
+    expect(src.calls()).toBe(1);
+  });
+
+  it.each([
+    ["prod_fixture_quarterly", "product_held"],
+    ["prod_t_period", "product_held"],
+    ["prod_t_nokey", "product_held"],
+    ["prod_t_conflict_a", "product_held"],
+    ["prod_t_conflict_b", "product_held"],
+    ["prod_fixture_legacy", "product_held"],
+    ["prod_t_inactive", "product_not_in_catalog"],
+    ["prod_absent", "product_not_in_catalog"],
+  ])("refuses %s as %s and writes nothing", async (id, reason) => {
+    const result = await setOrgEnabledProducts(
+      FIXTURE_ORG,
+      ["prod_fixture_basic", id],
+      countingSource().sourceFor,
+      { now: FIXTURE_NOW, ...noValidate },
+    );
+    expect(result).toEqual({ kind: "refused", reason });
+    expect(db.organizationOfferings.upsert).not.toHaveBeenCalled();
+    expect(storedSet()).toEqual(["prod_fixture_growth", "prod_fixture_quarterly"]);
+  });
+
+  it("answers product_not_in_catalog when a set holds both an unknown and a held id", async () => {
+    const result = await setOrgEnabledProducts(
+      FIXTURE_ORG,
+      ["prod_fixture_quarterly", "prod_absent"],
+      countingSource().sourceFor,
+      { now: FIXTURE_NOW, ...noValidate },
+    );
+    expect(result).toEqual({ kind: "refused", reason: "product_not_in_catalog" });
+  });
+
+  it("refuses with no connection and with a corrupt one, without building a source or writing", async () => {
+    await expect(
+      setOrgEnabledProducts(FIXTURE_ORG_2, [], refusingSourceFor, { now: FIXTURE_NOW, ...noValidate }),
+    ).resolves.toEqual({ kind: "not_connected" });
+    corruptConnection();
+    await expect(
+      setOrgEnabledProducts(FIXTURE_ORG, [], refusingSourceFor, { now: FIXTURE_NOW, ...noValidate }),
+    ).resolves.toEqual({ kind: "connection_unreadable" });
+    expect(db.organizationOfferings.upsert).not.toHaveBeenCalled();
+  });
+
+  it("writes nothing when the response parse throws (D3 step 4, AC-4)", async () => {
+    const validate = jest.fn(() => {
+      throw new Error("response failed its schema");
+    });
+    await expect(
+      setOrgEnabledProducts(FIXTURE_ORG, ["prod_fixture_basic"], countingSource().sourceFor, {
+        now: FIXTURE_NOW,
+        validate,
+      }),
+    ).rejects.toThrow("response failed its schema");
+    expect(validate).toHaveBeenCalledTimes(1);
+    expect(db.organizationOfferings.upsert).not.toHaveBeenCalled();
+    expect(storedSet()).toEqual(["prod_fixture_growth", "prod_fixture_quarterly"]);
+  });
+
+  it("stores an empty set, creating the row for an Organization that had none", async () => {
+    db.__db.organizationOfferings = [];
+    const result = await setOrgEnabledProducts(FIXTURE_ORG, [], countingSource().sourceFor, {
+      now: FIXTURE_NOW,
+      ...noValidate,
+    });
+    expect(result).toMatchObject({ kind: "written", previous: [] });
+    expect(storedSet()).toEqual([]);
+  });
+});
+
+describe("writeEnabledProductIds (#8922 D4)", () => {
+  it.each([
+    ["101 ids", Array.from({ length: 101 }, (_, i) => `prod_${i}`)],
+    ["a duplicate", ["prod_a", "prod_a"]],
+    ["a malformed id", ["bad id!"]],
+  ])("refuses %s with OfferingsShapeError, writing nothing", async (_label, ids) => {
+    await expect(writeEnabledProductIds(FIXTURE_ORG, ids)).rejects.toBeInstanceOf(OfferingsShapeError);
+    expect(db.organizationOfferings.upsert).not.toHaveBeenCalled();
+  });
+});
+
+// ─── AC-7 — one catalog read per Organization per minute ────────────────────
+
+describe("the owner path shares the per-minute read (#8922 D3, AC-7)", () => {
+  it("serves a list, a write and a read inside one minute from one source call", async () => {
+    const src = countingSource();
+    await listOrgProducts(FIXTURE_ORG, src.sourceFor, { now: at(0) });
+    await setOrgEnabledProducts(FIXTURE_ORG, ["prod_fixture_basic"], src.sourceFor, {
+      now: at(20 * SECOND),
+      ...noValidate,
+    });
+    await getOrgEnabledProducts(FIXTURE_ORG, src.sourceFor, { now: at(40 * SECOND) });
+    expect(src.calls()).toBe(1);
+
+    await Promise.all(
+      Array.from({ length: 5 }, () => listOrgProducts(FIXTURE_ORG, src.sourceFor, { now: at(61 * SECOND) })),
+    );
+    expect(src.calls()).toBe(2);
+    expect(new Set(src.asked)).toEqual(new Set([FIXTURE_ORG]));
+  });
+
+  it("holds the Organization for a minute after a failed read, and writes nothing", async () => {
+    const failing = countingSource(new Error("stripe down"));
+    await expect(listOrgProducts(FIXTURE_ORG, failing.sourceFor, { now: at(0) })).rejects.toBeInstanceOf(
+      OfferingsSourceError,
+    );
+    const fresh = countingSource();
+    await expect(listOrgProducts(FIXTURE_ORG, fresh.sourceFor, { now: at(30 * SECOND) })).rejects.toBeInstanceOf(
+      OfferingsSourceError,
+    );
+    await expect(
+      setOrgEnabledProducts(FIXTURE_ORG, ["prod_fixture_basic"], fresh.sourceFor, {
+        now: at(30 * SECOND),
+        ...noValidate,
+      }),
+    ).rejects.toBeInstanceOf(OfferingsSourceError);
+    expect(fresh.calls()).toBe(0);
+    expect(db.organizationOfferings.upsert).not.toHaveBeenCalled();
+  });
+});