@pipeline-builder/pipeline-data 4.3.2 → 4.3.4

package/lib/api/support-cases.js

@@ -0,0 +1,671 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Support-case persistence: the workflow half of a support thread.
+ *
+ * Here rather than in a service because two callers need it — platform owns the
+ * entitlement check and the writes, and the message service owns the thread the
+ * case points at — and neither should grow its own copy of the allocator.
+ *
+ * `messages` keeps carrying the conversation. These functions only ever touch
+ * the workflow axis: identity, status, ownership and the response clock.
+ */
+import { and, asc, eq, gte, inArray, isNull, lte, sql } from 'drizzle-orm';
+import { schema } from '../database/drizzle-schema.js';
+import { runWithTenantContext, withTenantTx } from '../database/tenancy.js';
+/** Statuses a case can be in. `awaiting_customer` is what stops the clock. */
+export const SUPPORT_CASE_STATUSES = ['open', 'awaiting_support', 'awaiting_customer', 'resolved', 'closed'];
+/** The statuses the staff queue asks about — the ones still on us. */
+export const QUEUE_STATUSES = ['open', 'awaiting_support'];
+/**
+ * Allocate the next per-org case number.
+ *
+ * Postgres sequences are global and cannot be per-org without one sequence per
+ * tenant, so the counter is a row. `UPDATE … RETURNING` takes the row lock,
+ * which serialises concurrent opens WITHIN one org while leaving other orgs
+ * untouched — a global sequence would serialise everybody, and would also
+ * disclose total case volume to every customer.
+ *
+ * The upsert seeds `next_number = 2` on first use and returns 1, so an org's
+ * first case is `ACME-1`. Must run inside the same transaction as the case
+ * insert: a committed allocation with a rolled-back insert burns a number, and
+ * a number burned is a gap a customer will eventually ask about.
+ */
+async function allocateDisplayNumber(tx, orgId) {
+    const rows = await tx
+        .insert(schema.supportCaseCounter)
+        .values({ orgId, nextNumber: 2 })
+        .onConflictDoUpdate({
+        target: schema.supportCaseCounter.orgId,
+        set: {
+            nextNumber: sql `${schema.supportCaseCounter.nextNumber} + 1`,
+            updatedAt: new Date(),
+        },
+    })
+        .returning({ next: schema.supportCaseCounter.nextNumber });
+    const next = rows[0]?.next;
+    if (next === undefined)
+        throw new Error('support case number allocation returned no row');
+    // On INSERT the row is seeded at 2 and this case is 1; on UPDATE the stored
+    // value has already been incremented, so this case is the value minus one.
+    // Both branches therefore yield "the number just consumed".
+    return next - 1;
+}
+/**
+ * Open a case for an existing thread, allocating its display number.
+ *
+ * One transaction on purpose: the number and the row commit together or neither
+ * does. `support_case_org_number_uq` is the backstop — if the allocator is ever
+ * bypassed, the insert fails rather than issuing two cases the one identifier
+ * customers quote back.
+ */
+export async function openSupportCase(input) {
+    return withTenantTx(async (tx) => {
+        const displayNumber = await allocateDisplayNumber(tx, input.orgId);
+        const rows = await tx
+            .insert(schema.supportCase)
+            .values({
+            threadId: input.threadId,
+            orgId: input.orgId,
+            displayNumber,
+            status: 'open',
+            severity: input.severity,
+            level: input.level,
+            openedWithIncident: input.openedWithIncident ?? false,
+            // Frozen at open, like `level`: a working-week or holiday change must
+            // not move a promise already made.
+            responseDueAt: input.responseDueAt ?? null,
+            // The opener owns it on the tenant side until it is handed over.
+            tenantContact: input.openedBy,
+            createdBy: input.openedBy,
+            updatedBy: input.openedBy,
+        })
+            .returning();
+        const row = rows[0];
+        if (!row)
+            throw new Error('support case insert returned no row');
+        return row;
+    });
+}
+/** The case for a thread, or null. The thread root id IS the case identity. */
+export async function findCaseByThread(threadId) {
+    const rows = await withTenantTx((tx) => tx
+        .select()
+        .from(schema.supportCase)
+        .where(and(eq(schema.supportCase.threadId, threadId), isNull(schema.supportCase.deletedAt)))
+        .limit(1));
+    return rows[0] ?? null;
+}
+/**
+ * The staff queue: open cases across ALL tenants, oldest first.
+ *
+ * The one read with no org predicate, so it runs under sysadmin scope and is
+ * served by the partial `support_case_queue_idx`.
+ *
+ * Ordered by `response_due_at` ASCENDING, NULLS LAST — soonest deadline first,
+ * which is what "most at risk" actually means. Arrival order was the earlier
+ * proxy for it and is a poor one: a standard case opened on Monday is owed
+ * Wednesday's close while a priority case opened on Tuesday is owed Wednesday's
+ * close too, so arrival order puts them in the wrong sequence whenever levels
+ * are mixed. Cases with no deadline (an unrecognised level, or one opened while
+ * the calendar was misconfigured) sort last rather than first, since a missing
+ * deadline is not an urgent one; `createdAt` breaks ties so the order is stable.
+ */
+export async function listQueue(limit = 100) {
+    return withTenantTx((tx) => tx
+        .select()
+        .from(schema.supportCase)
+        .where(and(inArray(schema.supportCase.status, [...QUEUE_STATUSES]), isNull(schema.supportCase.deletedAt)))
+        .orderBy(sql `${schema.supportCase.responseDueAt} ASC NULLS LAST`, asc(schema.supportCase.createdAt))
+        .limit(limit));
+}
+/**
+ * Premium cases whose response target is approaching with no first response yet.
+ *
+ * THE on-call sweep's only query, and the reason the pager is worth owning the
+ * trigger for: this is an EXACT per-case deadline, where the fleet alert
+ * (`SupportPremiumFirstResponseAtRisk`) is a p90 over six hours that can only
+ * say the distribution already drifted — never which case is about to breach.
+ *
+ * The predicate matches `support_case_response_due_idx` exactly, which is a
+ * PARTIAL index on `(response_due_at) WHERE level = 'support_premium' AND
+ * first_response_at IS NULL AND deleted_at IS NULL`. Note `level` and not
+ * `is_premium`: that column lives on support_CONTACTS and marks an upgraded
+ * contact, while a case freezes the opening contact's effective level at open —
+ * so the case's own promise is its `level`, and flipping the contact later must
+ * not change a deadline already published to a customer. That matters because this runs on a timer
+ * forever: the rows it wants are a tiny and shrinking fraction of the table, so
+ * the index stays small while the table grows, and without it every tick is a
+ * scan.
+ *
+ * Deliberately NOT filtered on status. A case that is `awaiting_support` and one
+ * that is `open` both owe a first response, and reading the status here would
+ * duplicate a rule that `first_response_at IS NULL` already states exactly.
+ */
+export async function listCasesDueForPage(leadMs, limit = 100) {
+    const cutoff = new Date(Date.now() + leadMs);
+    // THIS FUNCTION IS THE PRIVILEGE BOUNDARY, so the scope is established here
+    // rather than left to the caller. The sweep runs on a timer with no request
+    // and therefore no tenant context, and `support_cases` is RLS FORCE'd — so
+    // without a scope the read returns zero rows (and throws in production
+    // `strict` mode), which is the shape of a sweep that silently covers nothing.
+    // Cross-tenant is the point: one operator rota answers for every org's
+    // premium cases. Only IDS leave here; the pager never receives case content.
+    return runWithTenantContext({ isSuperAdmin: true }, () => withTenantTx((tx) => tx
+        .select()
+        .from(schema.supportCase)
+        .where(and(eq(schema.supportCase.level, 'support_premium'), isNull(schema.supportCase.firstResponseAt), isNull(schema.supportCase.deletedAt), lte(schema.supportCase.responseDueAt, cutoff)))
+        .orderBy(asc(schema.supportCase.responseDueAt))
+        .limit(limit)));
+}
+/** An org's own cases, newest first. */
+export async function listOrgCases(orgId, limit = 100) {
+    return withTenantTx((tx) => tx
+        .select()
+        .from(schema.supportCase)
+        .where(and(eq(schema.supportCase.orgId, orgId), isNull(schema.supportCase.deletedAt)))
+        .orderBy(sql `${schema.supportCase.createdAt} DESC`)
+        .limit(limit));
+}
+/**
+ * Stamp the first staff response, once.
+ *
+ * `first_response_at IS NULL` is in the WHERE clause rather than checked by the
+ * caller: this is THE number the response target is sold on, so a second reply
+ * must not be able to move it. Returns whether this call was the one that
+ * stamped it.
+ */
+export async function stampFirstResponse(caseId, at = new Date()) {
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportCase)
+        .set({ firstResponseAt: at, updatedAt: at })
+        .where(and(eq(schema.supportCase.id, caseId), isNull(schema.supportCase.firstResponseAt)))
+        .returning({ id: schema.supportCase.id }));
+    return rows.length > 0;
+}
+/**
+ * Move a case's status, maintaining the response clock.
+ *
+ * Entering `awaiting_customer` anchors `awaitingSince`; leaving it folds the
+ * elapsed span into `awaitingTotalSeconds` and clears the anchor. Ageing then
+ * subtracts the accumulator, so a case we answered in an hour and the tenant
+ * replied to four days later does not read as a four-day case — which is the
+ * number no customer would accept.
+ *
+ * The arithmetic is done in SQL against the stored anchor rather than from a
+ * caller-supplied duration, so a clock skew or a lost round trip cannot inflate
+ * or erase paused time.
+ */
+export async function setCaseStatus(caseId, status, actorId) {
+    const now = new Date();
+    const entering = status === 'awaiting_customer';
+    const closing = status === 'closed' || status === 'resolved';
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportCase)
+        .set({
+        status,
+        updatedBy: actorId,
+        updatedAt: now,
+        // Anchor on entry; on any other transition fold the open span in and clear.
+        awaitingSince: entering ? now : null,
+        awaitingTotalSeconds: entering
+            ? schema.supportCase.awaitingTotalSeconds
+            : sql `${schema.supportCase.awaitingTotalSeconds} + COALESCE(EXTRACT(EPOCH FROM (${now.toISOString()}::timestamptz - ${schema.supportCase.awaitingSince}))::int, 0)`,
+        ...(closing ? { closedAt: now, closedBy: actorId } : { closedAt: null, closedBy: null }),
+    })
+        .where(and(eq(schema.supportCase.id, caseId), isNull(schema.supportCase.deletedAt)))
+        .returning());
+    return rows[0] ?? null;
+}
+/**
+ * Re-rank a case's severity.
+ *
+ * STAFF ONLY at the route layer, and that is the governance point rather than a
+ * permission detail: the tenant chooses severity when opening, so if they could
+ * also change it afterwards they would unilaterally pick the response target
+ * they are owed. Severity decides which target applies, so re-ranking has to be
+ * ours.
+ */
+export async function setCaseSeverity(caseId, severity, actorId) {
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportCase)
+        .set({ severity, updatedBy: actorId, updatedAt: new Date() })
+        .where(and(eq(schema.supportCase.id, caseId), isNull(schema.supportCase.deletedAt)))
+        .returning({ severity: schema.supportCase.severity }));
+    return rows[0]?.severity ?? null;
+}
+/**
+ * Set or clear the STAFF owner.
+ *
+ * `null` is a legitimate value: it is the unowned pool, and how "I cannot take
+ * this" is expressed without inventing a pseudo-assignee.
+ */
+export async function assignCase(caseId, assignedTo, actorId) {
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportCase)
+        .set({ assignedTo, updatedBy: actorId, updatedAt: new Date() })
+        .where(and(eq(schema.supportCase.id, caseId), isNull(schema.supportCase.deletedAt)))
+        .returning());
+    return rows[0] ?? null;
+}
+/**
+ * Assign or release MANY cases at once.
+ *
+ * One statement rather than a loop, which is the point: a staff member clearing
+ * a queue of thirty selects thirty and acts once, and thirty round trips would
+ * make the obvious interaction the slow one. It also makes the write ATOMIC — a
+ * partial bulk assign leaves the queue in a state nobody chose, and the operator
+ * cannot tell which half took.
+ *
+ * Returns the ids that actually moved rather than a count, so a caller can
+ * report precisely what happened when the selection included something stale:
+ * a case closed or reassigned by somebody else between the read and the click.
+ * That is the normal case on a shared queue, not an edge one.
+ */
+export async function assignCases(caseIds, assignedTo, actorId) {
+    if (caseIds.length === 0)
+        return [];
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportCase)
+        .set({ assignedTo, updatedBy: actorId, updatedAt: new Date() })
+        .where(and(inArray(schema.supportCase.id, [...caseIds]), isNull(schema.supportCase.deletedAt)))
+        .returning({ id: schema.supportCase.id }));
+    return rows.map((r) => r.id);
+}
+/**
+ * Close MANY cases at once.
+ *
+ * Separate from {@link assignCases} rather than a generic bulk-update, because
+ * closing maintains the response clock — it folds the open awaiting span into
+ * the accumulator and stamps `closedAt` — and a generic setter would quietly
+ * skip that. The arithmetic is the same SQL `setCaseStatus` uses, for the same
+ * reason: done against the STORED anchor so a clock skew cannot inflate paused
+ * time.
+ *
+ * Only ever used to CLOSE. Bulk REOPENING is deliberately not offered: reopening
+ * is staff-only and case-by-case by design, and a bulk reopen is how a queue
+ * someone has finished with comes back all at once.
+ */
+export async function closeCases(caseIds, actorId) {
+    if (caseIds.length === 0)
+        return [];
+    const now = new Date();
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportCase)
+        .set({
+        status: 'closed',
+        closedAt: now,
+        closedBy: actorId,
+        updatedBy: actorId,
+        updatedAt: now,
+        awaitingSince: null,
+        awaitingTotalSeconds: sql `${schema.supportCase.awaitingTotalSeconds} + COALESCE(EXTRACT(EPOCH FROM (${now.toISOString()}::timestamptz - ${schema.supportCase.awaitingSince}))::int, 0)`,
+    })
+        .where(and(inArray(schema.supportCase.id, [...caseIds]), isNull(schema.supportCase.deletedAt), 
+    // Already-closed cases are skipped rather than re-stamped, so a bulk
+    // close over a selection that includes one does not move its closedAt.
+    sql `${schema.supportCase.status} <> 'closed'`))
+        .returning({ id: schema.supportCase.id }));
+    return rows.map((r) => r.id);
+}
+/**
+ * Hand the case to another tenant contact.
+ *
+ * Note what this does NOT touch: `createdBy`. That is the immutable audit fact
+ * of who raised the case — mutating it to express "someone else owns this now"
+ * would destroy the only record of who actually opened it. The caller must have
+ * already checked that the target is a live designated contact; this function
+ * will not infer entitlement from a user id.
+ */
+export async function transferCaseToContact(caseId, tenantContact, actorId) {
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportCase)
+        .set({ tenantContact, updatedBy: actorId, updatedAt: new Date() })
+        .where(and(eq(schema.supportCase.id, caseId), isNull(schema.supportCase.deletedAt)))
+        .returning());
+    return rows[0] ?? null;
+}
+/**
+ * A departing contact's open cases, so removal reassigns rather than orphans.
+ *
+ * Served by the partial `support_case_tenant_contact_idx`.
+ */
+export async function openCasesForContact(orgId, userId) {
+    return withTenantTx((tx) => tx
+        .select()
+        .from(schema.supportCase)
+        .where(and(eq(schema.supportCase.orgId, orgId), eq(schema.supportCase.tenantContact, userId), inArray(schema.supportCase.status, ['open', 'awaiting_support', 'awaiting_customer']), isNull(schema.supportCase.deletedAt))));
+}
+/**
+ * Cases raised across a scope within the last `windowDays` — the FAIR-USE count.
+ *
+ * WHAT IT IS FOR. Support is priced per CONTACT, and that unit assumes contacts
+ * proxy for case volume. At ten seats they do; at a hundred they do not — three
+ * named contacts become an internal help desk FORWARDING tickets, so the price
+ * buys the interface rather than the load. This is the measurement that notices.
+ *
+ * WHY NOT THE QUOTA SERVICE. `QUOTA_RESET_DAYS` makes every tracked quota a
+ * 3-day period, and a support allowance is monthly-shaped: five a month does not
+ * divide into three days without rounding to something either far too loose or
+ * useless. This table IS the counter — one range scan on
+ * `support_case_org_created_idx`, no period mismatch, and nothing to drift out
+ * of sync with reality.
+ *
+ * COUNTS EVERY CASE, INCLUDING CLOSED AND SOFT-DELETED. The question is how much
+ * support was CONSUMED in the window, and a case that was answered and closed
+ * consumed it just as much as an open one. Excluding closed cases would make the
+ * allowance trivially evadable by closing promptly — the opposite of the
+ * behaviour anyone wants to discourage.
+ */
+export async function countCasesInWindow(orgIds, windowDays) {
+    if (orgIds.length === 0 || windowDays <= 0)
+        return 0;
+    const since = new Date(Date.now() - windowDays * 86400_000);
+    const rows = await withTenantTx((tx) => tx
+        .select({ n: sql `count(*)::int` })
+        .from(schema.supportCase)
+        .where(and(inArray(schema.supportCase.orgId, [...orgIds]), gte(schema.supportCase.createdAt, since))));
+    return rows[0]?.n ?? 0;
+}
+/**
+ * Record the customer's verdict on a case.
+ *
+ * ONLY ON A TERMINAL CASE, enforced in the WHERE clause rather than by the
+ * caller: rating a case still being worked would measure an answer nobody has
+ * finished giving, and putting the condition in SQL means no route can forget
+ * it.
+ *
+ * RE-RATEABLE on purpose. A customer who rates in frustration and comes back a
+ * day later should be able to change it; freezing the first number would make
+ * the metric measure how people felt at their worst moment. `satisfaction_at`
+ * moves with it, so the ANSWER and WHEN it was given stay together.
+ *
+ * Returns whether a row moved — false means the case is missing, soft-deleted,
+ * or not closed yet, which the caller must distinguish from a stored zero.
+ */
+export async function rateCase(caseId, satisfaction, comment) {
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportCase)
+        .set({ satisfaction, satisfactionComment: comment, satisfactionAt: new Date() })
+        .where(and(eq(schema.supportCase.id, caseId), isNull(schema.supportCase.deletedAt), 
+    // Terminal only. `resolved` counts: we have claimed a fix, so the
+    // customer is in a position to say whether it was one.
+    inArray(schema.supportCase.status, ['resolved', 'closed'])))
+        .returning({ id: schema.supportCase.id }));
+    return rows.length > 0;
+}
+/**
+ * Add a staff-only note to a case.
+ *
+ * `orgId` is denormalised onto the row from the CASE, not taken from the author:
+ * a note belongs to the tenant whose case it annotates, and sourcing it from
+ * the staff author's own org (the system org) would put every note outside the
+ * tenant scope that is supposed to contain it.
+ *
+ * STAFF ONLY at the route layer, and the separate table is the reason that is
+ * safe: `messages` is read through one shared visibility predicate, so a flag
+ * there would leak an internal note from any read path that forgot the extra
+ * condition. A separate table cannot leak by omission — it has to be joined
+ * deliberately.
+ */
+export async function addCaseNote(caseId, orgId, content, createdBy) {
+    const rows = await withTenantTx((tx) => tx
+        .insert(schema.supportCaseNote)
+        .values({ caseId, orgId, content, createdBy })
+        .returning());
+    const row = rows[0];
+    if (!row)
+        throw new Error('support case note insert returned no row');
+    return row;
+}
+/** Live notes on a case, oldest first — they read as a running commentary. */
+export async function listCaseNotes(caseId) {
+    return withTenantTx((tx) => tx
+        .select()
+        .from(schema.supportCaseNote)
+        .where(and(eq(schema.supportCaseNote.caseId, caseId), eq(schema.supportCaseNote.isActive, true), isNull(schema.supportCaseNote.deletedAt)))
+        .orderBy(asc(schema.supportCaseNote.createdAt)));
+}
+/**
+ * Soft-delete a note.
+ *
+ * Soft because a note is a record of what the desk believed at the time, and a
+ * dispute may turn on it. Returns whether a row moved, so a second delete is a
+ * reported no-op rather than a silent success.
+ */
+export async function deleteCaseNote(noteId, deletedBy) {
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportCaseNote)
+        .set({ isActive: false, deletedAt: new Date(), deletedBy })
+        .where(and(eq(schema.supportCaseNote.id, noteId), eq(schema.supportCaseNote.isActive, true)))
+        .returning({ id: schema.supportCaseNote.id }));
+    return rows.length > 0;
+}
+/**
+ * Live templates, alphabetical — the picker's only query.
+ *
+ * No org scope because the table has none: these are the vendor's own wording
+ * for recurring questions, authored once and reused across every customer.
+ * Scoping them per tenant would be the opposite of the point.
+ */
+export async function listCannedResponses() {
+    return withTenantTx((tx) => tx
+        .select({
+        id: schema.supportCannedResponse.id,
+        title: schema.supportCannedResponse.title,
+        body: schema.supportCannedResponse.body,
+    })
+        .from(schema.supportCannedResponse)
+        .where(eq(schema.supportCannedResponse.isActive, true))
+        .orderBy(asc(schema.supportCannedResponse.title)));
+}
+/** Create a template. */
+export async function createCannedResponse(title, body, actorId) {
+    const rows = await withTenantTx((tx) => tx
+        .insert(schema.supportCannedResponse)
+        .values({ title, body, createdBy: actorId, updatedBy: actorId })
+        .returning({
+        id: schema.supportCannedResponse.id,
+        title: schema.supportCannedResponse.title,
+        body: schema.supportCannedResponse.body,
+    }));
+    const row = rows[0];
+    if (!row)
+        throw new Error('canned response insert returned no row');
+    return row;
+}
+/**
+ * Edit a live template.
+ *
+ * Guarded on `is_active` so a retired template cannot be edited back into
+ * circulation — a resurrection should be a deliberate new row, not a side
+ * effect of fixing a typo.
+ */
+export async function updateCannedResponse(id, fields, actorId) {
+    if (fields.title === undefined && fields.body === undefined)
+        return false;
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportCannedResponse)
+        .set({
+        ...(fields.title !== undefined ? { title: fields.title } : {}),
+        ...(fields.body !== undefined ? { body: fields.body } : {}),
+        updatedBy: actorId,
+        updatedAt: new Date(),
+    })
+        .where(and(eq(schema.supportCannedResponse.id, id), eq(schema.supportCannedResponse.isActive, true)))
+        .returning({ id: schema.supportCannedResponse.id }));
+    return rows.length > 0;
+}
+/**
+ * Retire a template.
+ *
+ * SOFT, because a retired template is still the explanation of what a past
+ * reply said — deleting the row would leave old correspondence unaccountable
+ * for its own wording.
+ */
+export async function deleteCannedResponse(id, actorId) {
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportCannedResponse)
+        .set({ isActive: false, updatedBy: actorId, updatedAt: new Date() })
+        .where(and(eq(schema.supportCannedResponse.id, id), eq(schema.supportCannedResponse.isActive, true)))
+        .returning({ id: schema.supportCannedResponse.id }));
+    return rows.length > 0;
+}
+// --- Support contacts -------------------------------------------------------
+/**
+ * Live designated contacts across a set of orgs (an account subtree).
+ *
+ * Takes the whole scope in one query rather than per-org because the allowance
+ * POOLS at the root: a person designated on a team spends the account's
+ * allowance, so counting team-by-team and summing would be the same number by
+ * accident and the wrong shape the moment pooling changes.
+ */
+export async function countActiveSupportContacts(orgIds) {
+    // Callers pass the expanded SUBTREE for the pooled cap, or a single org to ask
+    // "may a case raised here have an owner at all". Both are legitimate; see
+    // `SupportEntitlement` in platform for which field is which.
+    if (orgIds.length === 0)
+        return 0;
+    const rows = await withTenantTx((tx) => tx
+        .select({ n: sql `count(*)::int` })
+        .from(schema.supportContact)
+        .where(and(inArray(schema.supportContact.orgId, [...orgIds]), eq(schema.supportContact.isActive, true))));
+    return rows[0]?.n ?? 0;
+}
+/**
+ * Live contacts for the tenant owner picker.
+ *
+ * SCOPE IS THE CALLER'S CHOICE, and the default is ONE ORG. The allowance pools
+ * subtree-wide, but ownership does not: a team reassigns a case only among its
+ * OWN contacts, so a pooled allowance never turns into one team's cases being
+ * readable by a sibling. Pass a single org id for the picker; pass the expanded
+ * subtree only where the pooled CAP is the question (see
+ * `countActiveSupportContacts`).
+ *
+ * Taking a list rather than a single id keeps that decision at the call site
+ * instead of hiding it here — the two scopes answer differently and the wrong
+ * one leaks cases across teams.
+ */
+export async function listActiveSupportContacts(orgIds) {
+    if (orgIds.length === 0)
+        return [];
+    return withTenantTx((tx) => tx
+        .select({
+        orgId: schema.supportContact.orgId,
+        userId: schema.supportContact.userId,
+        // Carried so the admin panel can show who is upgraded without a second
+        // query, and so the tenant owner picker can say which contacts carry 24x7.
+        isPremium: schema.supportContact.isPremium,
+    })
+        .from(schema.supportContact)
+        .where(and(inArray(schema.supportContact.orgId, [...orgIds]), eq(schema.supportContact.isActive, true))));
+}
+/**
+ * Whether this user is a live designated contact in any org of the scope.
+ *
+ * Transfer validation must pass the case's OWN org, not the subtree: accepting a
+ * sibling team's contact as a valid transfer target is exactly the cross-team
+ * leak the own-org ownership rule exists to prevent.
+ */
+export async function isSupportContact(orgIds, userId) {
+    if (orgIds.length === 0)
+        return false;
+    const rows = await withTenantTx((tx) => tx
+        .select({ id: schema.supportContact.id })
+        .from(schema.supportContact)
+        .where(and(inArray(schema.supportContact.orgId, [...orgIds]), eq(schema.supportContact.userId, userId), eq(schema.supportContact.isActive, true)))
+        .limit(1));
+    return rows.length > 0;
+}
+/**
+ * Designate a support contact.
+ *
+ * The CAP is not enforced here — the caller holds it, because the limit lives on
+ * the Mongo org doc and this module only reaches Postgres. Mirrors how seats are
+ * capped in platform rather than in the row writer.
+ *
+ * `support_contact_org_user_uq` is partial on `is_active = true`, so
+ * re-designating someone previously revoked inserts a fresh row rather than
+ * colliding — the revoked row stays as the record that they once held it.
+ */
+export async function designateSupportContact(orgId, userId, designatedBy, isPremium = false) {
+    await withTenantTx(async (tx) => {
+        await tx.insert(schema.supportContact)
+            .values({ orgId, userId, designatedBy, isPremium })
+            .onConflictDoNothing();
+    });
+}
+/**
+ * Live contacts in a scope that are UPGRADED to premium — the cap's counterpart.
+ *
+ * Counted separately from the baseline total because the two caps are separate:
+ * an account holds N contacts (`supportContacts`) and upgrades M of them
+ * (`supportPremiumContacts`), M ≤ N. Pooled over whatever scope the caller
+ * passes, exactly like {@link countActiveSupportContacts} — subtree for the cap,
+ * one org for an ownership question.
+ */
+export async function countPremiumSupportContacts(orgIds) {
+    if (orgIds.length === 0)
+        return 0;
+    const rows = await withTenantTx((tx) => tx
+        .select({ n: sql `count(*)::int` })
+        .from(schema.supportContact)
+        .where(and(inArray(schema.supportContact.orgId, [...orgIds]), eq(schema.supportContact.isActive, true), eq(schema.supportContact.isPremium, true))));
+    return rows[0]?.n ?? 0;
+}
+/**
+ * Whether this user is a live PREMIUM contact in the scope.
+ *
+ * The case-open path reads this to decide which level to freeze onto a new case:
+ * premium when the opener is upgraded, the account's baseline otherwise. Pass the
+ * case's OWN org — the upgrade follows the person in the org that nominated
+ * them, and a sibling team's upgrade is not this org's to spend.
+ */
+export async function isPremiumSupportContact(orgIds, userId) {
+    if (orgIds.length === 0)
+        return false;
+    const rows = await withTenantTx((tx) => tx
+        .select({ id: schema.supportContact.id })
+        .from(schema.supportContact)
+        .where(and(inArray(schema.supportContact.orgId, [...orgIds]), eq(schema.supportContact.userId, userId), eq(schema.supportContact.isActive, true), eq(schema.supportContact.isPremium, true)))
+        .limit(1));
+    return rows.length > 0;
+}
+/**
+ * Upgrade or downgrade a LIVE contact.
+ *
+ * Guarded on `is_active` so a revoked row cannot be upgraded back into
+ * relevance, and returns whether a row actually moved — the caller counts
+ * against the premium cap before calling, and a silent no-op would let that
+ * count drift from reality.
+ *
+ * Deliberately does NOT touch the case rows: `support_case.level` is frozen at
+ * open, so downgrading somebody never weakens a promise already made on a case
+ * they raised while upgraded.
+ */
+export async function setSupportContactPremium(orgId, userId, isPremium) {
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportContact)
+        .set({ isPremium })
+        .where(and(eq(schema.supportContact.orgId, orgId), eq(schema.supportContact.userId, userId), eq(schema.supportContact.isActive, true)))
+        .returning({ id: schema.supportContact.id }));
+    return rows.length > 0;
+}
+/**
+ * Revoke a designation, freeing the slot.
+ *
+ * Returns the user's still-open cases so the caller can reassign them instead of
+ * orphaning — scope C4's answer. Revoking is deliberately not blocked on them:
+ * refusing to remove a departed employee because they still own cases would be
+ * worse than handing the cases on.
+ */
+export async function revokeSupportContact(orgId, userId, revokedBy) {
+    const openCases = await openCasesForContact(orgId, userId);
+    const rows = await withTenantTx((tx) => tx
+        .update(schema.supportContact)
+        .set({ isActive: false, revokedAt: new Date(), revokedBy })
+        .where(and(eq(schema.supportContact.orgId, orgId), eq(schema.supportContact.userId, userId), eq(schema.supportContact.isActive, true)))
+        .returning({ id: schema.supportContact.id }));
+    return { revoked: rows.length > 0, openCases };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"support-cases.js","sourceRoot":"","sources":["../../src/api/support-cases.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n/**\n * Support-case persistence: the workflow half of a support thread.\n *\n * Here rather than in a service because two callers need it — platform owns the\n * entitlement check and the writes, and the message service owns the thread the\n * case points at — and neither should grow its own copy of the allocator.\n *\n * `messages` keeps carrying the conversation. These functions only ever touch\n * the workflow axis: identity, status, ownership and the response clock.\n */\n\nimport { and, asc, eq, gte, inArray, isNull, lte, sql } from 'drizzle-orm';\nimport { schema } from '../database/drizzle-schema.js';\nimport type { SupportCase } from '../database/schema/support.js';\nimport { runWithTenantContext, withTenantTx } from '../database/tenancy.js';\n\n/** Statuses a case can be in. `awaiting_customer` is what stops the clock. */\nexport const SUPPORT_CASE_STATUSES = ['open', 'awaiting_support', 'awaiting_customer', 'resolved', 'closed'] as const;\nexport type SupportCaseStatus = (typeof SUPPORT_CASE_STATUSES)[number];\n\n/** The statuses the staff queue asks about — the ones still on us. */\nexport const QUEUE_STATUSES: readonly SupportCaseStatus[] = ['open', 'awaiting_support'];\n\n/** What opening a case needs. `level` is frozen onto the row at open. */\nexport interface OpenCaseInput {\n  /** The root `messages.id`. Becomes the canonical case identity. */\n  threadId: string;\n  orgId: string;\n  /** The support level HELD AT OPEN, frozen so a mid-case downgrade cannot\n   *  change the promise underneath someone already waiting. */\n  level: string;\n  severity: string;\n  /** The opener. Also the initial tenant owner when they are a contact. */\n  openedBy: string;\n  /** True when the case was opened by spending a one-time incident rather than\n   *  against a contact seat, so incident usage is answerable from the cases\n   *  themselves and not only from a balance delta. */\n  openedWithIncident?: boolean;\n  /**\n   * When the first response is due, already computed by the caller.\n   *\n   * Passed IN rather than derived here: the business calendar is deployment\n   * config (`SUPPORT_BUSINESS_HOURS_*`) read by api-core's `responseDueAt`, and\n   * this module must not reach for env to answer a product question. Null is a\n   * legitimate value — a level with no published target, or a calendar too\n   * broken to derive one — and is stored as \"no deadline\" rather than guessed.\n   */\n  responseDueAt?: Date | null;\n}\n\n/**\n * Allocate the next per-org case number.\n *\n * Postgres sequences are global and cannot be per-org without one sequence per\n * tenant, so the counter is a row. `UPDATE … RETURNING` takes the row lock,\n * which serialises concurrent opens WITHIN one org while leaving other orgs\n * untouched — a global sequence would serialise everybody, and would also\n * disclose total case volume to every customer.\n *\n * The upsert seeds `next_number = 2` on first use and returns 1, so an org's\n * first case is `ACME-1`. Must run inside the same transaction as the case\n * insert: a committed allocation with a rolled-back insert burns a number, and\n * a number burned is a gap a customer will eventually ask about.\n */\nasync function allocateDisplayNumber(tx: Parameters<Parameters<typeof withTenantTx>[0]>[0], orgId: string): Promise<number> {\n  const rows = await tx\n    .insert(schema.supportCaseCounter)\n    .values({ orgId, nextNumber: 2 })\n    .onConflictDoUpdate({\n      target: schema.supportCaseCounter.orgId,\n      set: {\n        nextNumber: sql`${schema.supportCaseCounter.nextNumber} + 1`,\n        updatedAt: new Date(),\n      },\n    })\n    .returning({ next: schema.supportCaseCounter.nextNumber });\n  const next = rows[0]?.next;\n  if (next === undefined) throw new Error('support case number allocation returned no row');\n  // On INSERT the row is seeded at 2 and this case is 1; on UPDATE the stored\n  // value has already been incremented, so this case is the value minus one.\n  // Both branches therefore yield \"the number just consumed\".\n  return next - 1;\n}\n\n/**\n * Open a case for an existing thread, allocating its display number.\n *\n * One transaction on purpose: the number and the row commit together or neither\n * does. `support_case_org_number_uq` is the backstop — if the allocator is ever\n * bypassed, the insert fails rather than issuing two cases the one identifier\n * customers quote back.\n */\nexport async function openSupportCase(input: OpenCaseInput): Promise<SupportCase> {\n  return withTenantTx(async (tx) => {\n    const displayNumber = await allocateDisplayNumber(tx, input.orgId);\n    const rows = await tx\n      .insert(schema.supportCase)\n      .values({\n        threadId: input.threadId,\n        orgId: input.orgId,\n        displayNumber,\n        status: 'open',\n        severity: input.severity,\n        level: input.level,\n        openedWithIncident: input.openedWithIncident ?? false,\n        // Frozen at open, like `level`: a working-week or holiday change must\n        // not move a promise already made.\n        responseDueAt: input.responseDueAt ?? null,\n        // The opener owns it on the tenant side until it is handed over.\n        tenantContact: input.openedBy,\n        createdBy: input.openedBy,\n        updatedBy: input.openedBy,\n      })\n      .returning();\n    const row = rows[0];\n    if (!row) throw new Error('support case insert returned no row');\n    return row;\n  });\n}\n\n/** The case for a thread, or null. The thread root id IS the case identity. */\nexport async function findCaseByThread(threadId: string): Promise<SupportCase | null> {\n  const rows = await withTenantTx((tx) => tx\n    .select()\n    .from(schema.supportCase)\n    .where(and(eq(schema.supportCase.threadId, threadId), isNull(schema.supportCase.deletedAt)))\n    .limit(1));\n  return rows[0] ?? null;\n}\n\n/**\n * The staff queue: open cases across ALL tenants, oldest first.\n *\n * The one read with no org predicate, so it runs under sysadmin scope and is\n * served by the partial `support_case_queue_idx`.\n *\n * Ordered by `response_due_at` ASCENDING, NULLS LAST — soonest deadline first,\n * which is what \"most at risk\" actually means. Arrival order was the earlier\n * proxy for it and is a poor one: a standard case opened on Monday is owed\n * Wednesday's close while a priority case opened on Tuesday is owed Wednesday's\n * close too, so arrival order puts them in the wrong sequence whenever levels\n * are mixed. Cases with no deadline (an unrecognised level, or one opened while\n * the calendar was misconfigured) sort last rather than first, since a missing\n * deadline is not an urgent one; `createdAt` breaks ties so the order is stable.\n */\nexport async function listQueue(limit = 100): Promise<SupportCase[]> {\n  return withTenantTx((tx) => tx\n    .select()\n    .from(schema.supportCase)\n    .where(and(\n      inArray(schema.supportCase.status, [...QUEUE_STATUSES]),\n      isNull(schema.supportCase.deletedAt),\n    ))\n    .orderBy(sql`${schema.supportCase.responseDueAt} ASC NULLS LAST`, asc(schema.supportCase.createdAt))\n    .limit(limit));\n}\n\n/**\n * Premium cases whose response target is approaching with no first response yet.\n *\n * THE on-call sweep's only query, and the reason the pager is worth owning the\n * trigger for: this is an EXACT per-case deadline, where the fleet alert\n * (`SupportPremiumFirstResponseAtRisk`) is a p90 over six hours that can only\n * say the distribution already drifted — never which case is about to breach.\n *\n * The predicate matches `support_case_response_due_idx` exactly, which is a\n * PARTIAL index on `(response_due_at) WHERE level = 'support_premium' AND\n * first_response_at IS NULL AND deleted_at IS NULL`. Note `level` and not\n * `is_premium`: that column lives on support_CONTACTS and marks an upgraded\n * contact, while a case freezes the opening contact's effective level at open —\n * so the case's own promise is its `level`, and flipping the contact later must\n * not change a deadline already published to a customer. That matters because this runs on a timer\n * forever: the rows it wants are a tiny and shrinking fraction of the table, so\n * the index stays small while the table grows, and without it every tick is a\n * scan.\n *\n * Deliberately NOT filtered on status. A case that is `awaiting_support` and one\n * that is `open` both owe a first response, and reading the status here would\n * duplicate a rule that `first_response_at IS NULL` already states exactly.\n */\nexport async function listCasesDueForPage(leadMs: number, limit = 100): Promise<SupportCase[]> {\n  const cutoff = new Date(Date.now() + leadMs);\n  // THIS FUNCTION IS THE PRIVILEGE BOUNDARY, so the scope is established here\n  // rather than left to the caller. The sweep runs on a timer with no request\n  // and therefore no tenant context, and `support_cases` is RLS FORCE'd — so\n  // without a scope the read returns zero rows (and throws in production\n  // `strict` mode), which is the shape of a sweep that silently covers nothing.\n  // Cross-tenant is the point: one operator rota answers for every org's\n  // premium cases. Only IDS leave here; the pager never receives case content.\n  return runWithTenantContext({ isSuperAdmin: true }, () => withTenantTx((tx) => tx\n    .select()\n    .from(schema.supportCase)\n    .where(and(\n      eq(schema.supportCase.level, 'support_premium'),\n      isNull(schema.supportCase.firstResponseAt),\n      isNull(schema.supportCase.deletedAt),\n      lte(schema.supportCase.responseDueAt, cutoff),\n    ))\n    .orderBy(asc(schema.supportCase.responseDueAt))\n    .limit(limit)));\n}\n\n/** An org's own cases, newest first. */\nexport async function listOrgCases(orgId: string, limit = 100): Promise<SupportCase[]> {\n  return withTenantTx((tx) => tx\n    .select()\n    .from(schema.supportCase)\n    .where(and(eq(schema.supportCase.orgId, orgId), isNull(schema.supportCase.deletedAt)))\n    .orderBy(sql`${schema.supportCase.createdAt} DESC`)\n    .limit(limit));\n}\n\n/**\n * Stamp the first staff response, once.\n *\n * `first_response_at IS NULL` is in the WHERE clause rather than checked by the\n * caller: this is THE number the response target is sold on, so a second reply\n * must not be able to move it. Returns whether this call was the one that\n * stamped it.\n */\nexport async function stampFirstResponse(caseId: string, at: Date = new Date()): Promise<boolean> {\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportCase)\n    .set({ firstResponseAt: at, updatedAt: at })\n    .where(and(eq(schema.supportCase.id, caseId), isNull(schema.supportCase.firstResponseAt)))\n    .returning({ id: schema.supportCase.id }));\n  return rows.length > 0;\n}\n\n/**\n * Move a case's status, maintaining the response clock.\n *\n * Entering `awaiting_customer` anchors `awaitingSince`; leaving it folds the\n * elapsed span into `awaitingTotalSeconds` and clears the anchor. Ageing then\n * subtracts the accumulator, so a case we answered in an hour and the tenant\n * replied to four days later does not read as a four-day case — which is the\n * number no customer would accept.\n *\n * The arithmetic is done in SQL against the stored anchor rather than from a\n * caller-supplied duration, so a clock skew or a lost round trip cannot inflate\n * or erase paused time.\n */\nexport async function setCaseStatus(\n  caseId: string,\n  status: SupportCaseStatus,\n  actorId: string,\n): Promise<SupportCase | null> {\n  const now = new Date();\n  const entering = status === 'awaiting_customer';\n  const closing = status === 'closed' || status === 'resolved';\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportCase)\n    .set({\n      status,\n      updatedBy: actorId,\n      updatedAt: now,\n      // Anchor on entry; on any other transition fold the open span in and clear.\n      awaitingSince: entering ? now : null,\n      awaitingTotalSeconds: entering\n        ? schema.supportCase.awaitingTotalSeconds\n        : sql`${schema.supportCase.awaitingTotalSeconds} + COALESCE(EXTRACT(EPOCH FROM (${now.toISOString()}::timestamptz - ${schema.supportCase.awaitingSince}))::int, 0)`,\n      ...(closing ? { closedAt: now, closedBy: actorId } : { closedAt: null, closedBy: null }),\n    })\n    .where(and(eq(schema.supportCase.id, caseId), isNull(schema.supportCase.deletedAt)))\n    .returning());\n  return rows[0] ?? null;\n}\n\n/**\n * Re-rank a case's severity.\n *\n * STAFF ONLY at the route layer, and that is the governance point rather than a\n * permission detail: the tenant chooses severity when opening, so if they could\n * also change it afterwards they would unilaterally pick the response target\n * they are owed. Severity decides which target applies, so re-ranking has to be\n * ours.\n */\nexport async function setCaseSeverity(caseId: string, severity: string, actorId: string): Promise<string | null> {\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportCase)\n    .set({ severity, updatedBy: actorId, updatedAt: new Date() })\n    .where(and(eq(schema.supportCase.id, caseId), isNull(schema.supportCase.deletedAt)))\n    .returning({ severity: schema.supportCase.severity }));\n  return rows[0]?.severity ?? null;\n}\n\n/**\n * Set or clear the STAFF owner.\n *\n * `null` is a legitimate value: it is the unowned pool, and how \"I cannot take\n * this\" is expressed without inventing a pseudo-assignee.\n */\nexport async function assignCase(caseId: string, assignedTo: string | null, actorId: string): Promise<SupportCase | null> {\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportCase)\n    .set({ assignedTo, updatedBy: actorId, updatedAt: new Date() })\n    .where(and(eq(schema.supportCase.id, caseId), isNull(schema.supportCase.deletedAt)))\n    .returning());\n  return rows[0] ?? null;\n}\n\n/**\n * Assign or release MANY cases at once.\n *\n * One statement rather than a loop, which is the point: a staff member clearing\n * a queue of thirty selects thirty and acts once, and thirty round trips would\n * make the obvious interaction the slow one. It also makes the write ATOMIC — a\n * partial bulk assign leaves the queue in a state nobody chose, and the operator\n * cannot tell which half took.\n *\n * Returns the ids that actually moved rather than a count, so a caller can\n * report precisely what happened when the selection included something stale:\n * a case closed or reassigned by somebody else between the read and the click.\n * That is the normal case on a shared queue, not an edge one.\n */\nexport async function assignCases(\n  caseIds: readonly string[],\n  assignedTo: string | null,\n  actorId: string,\n): Promise<string[]> {\n  if (caseIds.length === 0) return [];\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportCase)\n    .set({ assignedTo, updatedBy: actorId, updatedAt: new Date() })\n    .where(and(\n      inArray(schema.supportCase.id, [...caseIds]),\n      isNull(schema.supportCase.deletedAt),\n    ))\n    .returning({ id: schema.supportCase.id }));\n  return rows.map((r) => r.id);\n}\n\n/**\n * Close MANY cases at once.\n *\n * Separate from {@link assignCases} rather than a generic bulk-update, because\n * closing maintains the response clock — it folds the open awaiting span into\n * the accumulator and stamps `closedAt` — and a generic setter would quietly\n * skip that. The arithmetic is the same SQL `setCaseStatus` uses, for the same\n * reason: done against the STORED anchor so a clock skew cannot inflate paused\n * time.\n *\n * Only ever used to CLOSE. Bulk REOPENING is deliberately not offered: reopening\n * is staff-only and case-by-case by design, and a bulk reopen is how a queue\n * someone has finished with comes back all at once.\n */\nexport async function closeCases(caseIds: readonly string[], actorId: string): Promise<string[]> {\n  if (caseIds.length === 0) return [];\n  const now = new Date();\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportCase)\n    .set({\n      status: 'closed',\n      closedAt: now,\n      closedBy: actorId,\n      updatedBy: actorId,\n      updatedAt: now,\n      awaitingSince: null,\n      awaitingTotalSeconds: sql`${schema.supportCase.awaitingTotalSeconds} + COALESCE(EXTRACT(EPOCH FROM (${now.toISOString()}::timestamptz - ${schema.supportCase.awaitingSince}))::int, 0)`,\n    })\n    .where(and(\n      inArray(schema.supportCase.id, [...caseIds]),\n      isNull(schema.supportCase.deletedAt),\n      // Already-closed cases are skipped rather than re-stamped, so a bulk\n      // close over a selection that includes one does not move its closedAt.\n      sql`${schema.supportCase.status} <> 'closed'`,\n    ))\n    .returning({ id: schema.supportCase.id }));\n  return rows.map((r) => r.id);\n}\n\n/**\n * Hand the case to another tenant contact.\n *\n * Note what this does NOT touch: `createdBy`. That is the immutable audit fact\n * of who raised the case — mutating it to express \"someone else owns this now\"\n * would destroy the only record of who actually opened it. The caller must have\n * already checked that the target is a live designated contact; this function\n * will not infer entitlement from a user id.\n */\nexport async function transferCaseToContact(caseId: string, tenantContact: string, actorId: string): Promise<SupportCase | null> {\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportCase)\n    .set({ tenantContact, updatedBy: actorId, updatedAt: new Date() })\n    .where(and(eq(schema.supportCase.id, caseId), isNull(schema.supportCase.deletedAt)))\n    .returning());\n  return rows[0] ?? null;\n}\n\n/**\n * A departing contact's open cases, so removal reassigns rather than orphans.\n *\n * Served by the partial `support_case_tenant_contact_idx`.\n */\nexport async function openCasesForContact(orgId: string, userId: string): Promise<SupportCase[]> {\n  return withTenantTx((tx) => tx\n    .select()\n    .from(schema.supportCase)\n    .where(and(\n      eq(schema.supportCase.orgId, orgId),\n      eq(schema.supportCase.tenantContact, userId),\n      inArray(schema.supportCase.status, ['open', 'awaiting_support', 'awaiting_customer']),\n      isNull(schema.supportCase.deletedAt),\n    )));\n}\n\n/**\n * Cases raised across a scope within the last `windowDays` — the FAIR-USE count.\n *\n * WHAT IT IS FOR. Support is priced per CONTACT, and that unit assumes contacts\n * proxy for case volume. At ten seats they do; at a hundred they do not — three\n * named contacts become an internal help desk FORWARDING tickets, so the price\n * buys the interface rather than the load. This is the measurement that notices.\n *\n * WHY NOT THE QUOTA SERVICE. `QUOTA_RESET_DAYS` makes every tracked quota a\n * 3-day period, and a support allowance is monthly-shaped: five a month does not\n * divide into three days without rounding to something either far too loose or\n * useless. This table IS the counter — one range scan on\n * `support_case_org_created_idx`, no period mismatch, and nothing to drift out\n * of sync with reality.\n *\n * COUNTS EVERY CASE, INCLUDING CLOSED AND SOFT-DELETED. The question is how much\n * support was CONSUMED in the window, and a case that was answered and closed\n * consumed it just as much as an open one. Excluding closed cases would make the\n * allowance trivially evadable by closing promptly — the opposite of the\n * behaviour anyone wants to discourage.\n */\nexport async function countCasesInWindow(orgIds: readonly string[], windowDays: number): Promise<number> {\n  if (orgIds.length === 0 || windowDays <= 0) return 0;\n  const since = new Date(Date.now() - windowDays * 86400_000);\n  const rows = await withTenantTx((tx) => tx\n    .select({ n: sql<number>`count(*)::int` })\n    .from(schema.supportCase)\n    .where(and(\n      inArray(schema.supportCase.orgId, [...orgIds]),\n      gte(schema.supportCase.createdAt, since),\n    )));\n  return rows[0]?.n ?? 0;\n}\n\n/**\n * Record the customer's verdict on a case.\n *\n * ONLY ON A TERMINAL CASE, enforced in the WHERE clause rather than by the\n * caller: rating a case still being worked would measure an answer nobody has\n * finished giving, and putting the condition in SQL means no route can forget\n * it.\n *\n * RE-RATEABLE on purpose. A customer who rates in frustration and comes back a\n * day later should be able to change it; freezing the first number would make\n * the metric measure how people felt at their worst moment. `satisfaction_at`\n * moves with it, so the ANSWER and WHEN it was given stay together.\n *\n * Returns whether a row moved — false means the case is missing, soft-deleted,\n * or not closed yet, which the caller must distinguish from a stored zero.\n */\nexport async function rateCase(\n  caseId: string,\n  satisfaction: number,\n  comment: string | null,\n): Promise<boolean> {\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportCase)\n    .set({ satisfaction, satisfactionComment: comment, satisfactionAt: new Date() })\n    .where(and(\n      eq(schema.supportCase.id, caseId),\n      isNull(schema.supportCase.deletedAt),\n      // Terminal only. `resolved` counts: we have claimed a fix, so the\n      // customer is in a position to say whether it was one.\n      inArray(schema.supportCase.status, ['resolved', 'closed']),\n    ))\n    .returning({ id: schema.supportCase.id }));\n  return rows.length > 0;\n}\n\n// --- Staff notes ------------------------------------------------------------\n\n/** One staff note, as the queue UI renders it. */\nexport interface SupportCaseNote {\n  id: string;\n  caseId: string;\n  content: string;\n  createdBy: string;\n  createdAt: Date;\n}\n\n/**\n * Add a staff-only note to a case.\n *\n * `orgId` is denormalised onto the row from the CASE, not taken from the author:\n * a note belongs to the tenant whose case it annotates, and sourcing it from\n * the staff author's own org (the system org) would put every note outside the\n * tenant scope that is supposed to contain it.\n *\n * STAFF ONLY at the route layer, and the separate table is the reason that is\n * safe: `messages` is read through one shared visibility predicate, so a flag\n * there would leak an internal note from any read path that forgot the extra\n * condition. A separate table cannot leak by omission — it has to be joined\n * deliberately.\n */\nexport async function addCaseNote(\n  caseId: string,\n  orgId: string,\n  content: string,\n  createdBy: string,\n): Promise<SupportCaseNote> {\n  const rows = await withTenantTx((tx) => tx\n    .insert(schema.supportCaseNote)\n    .values({ caseId, orgId, content, createdBy })\n    .returning());\n  const row = rows[0];\n  if (!row) throw new Error('support case note insert returned no row');\n  return row;\n}\n\n/** Live notes on a case, oldest first — they read as a running commentary. */\nexport async function listCaseNotes(caseId: string): Promise<SupportCaseNote[]> {\n  return withTenantTx((tx) => tx\n    .select()\n    .from(schema.supportCaseNote)\n    .where(and(\n      eq(schema.supportCaseNote.caseId, caseId),\n      eq(schema.supportCaseNote.isActive, true),\n      isNull(schema.supportCaseNote.deletedAt),\n    ))\n    .orderBy(asc(schema.supportCaseNote.createdAt)));\n}\n\n/**\n * Soft-delete a note.\n *\n * Soft because a note is a record of what the desk believed at the time, and a\n * dispute may turn on it. Returns whether a row moved, so a second delete is a\n * reported no-op rather than a silent success.\n */\nexport async function deleteCaseNote(noteId: string, deletedBy: string): Promise<boolean> {\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportCaseNote)\n    .set({ isActive: false, deletedAt: new Date(), deletedBy })\n    .where(and(\n      eq(schema.supportCaseNote.id, noteId),\n      eq(schema.supportCaseNote.isActive, true),\n    ))\n    .returning({ id: schema.supportCaseNote.id }));\n  return rows.length > 0;\n}\n\n// --- Canned responses -------------------------------------------------------\n\n/** A reusable staff reply template. */\nexport interface CannedResponse {\n  id: string;\n  title: string;\n  body: string;\n}\n\n/**\n * Live templates, alphabetical — the picker's only query.\n *\n * No org scope because the table has none: these are the vendor's own wording\n * for recurring questions, authored once and reused across every customer.\n * Scoping them per tenant would be the opposite of the point.\n */\nexport async function listCannedResponses(): Promise<CannedResponse[]> {\n  return withTenantTx((tx) => tx\n    .select({\n      id: schema.supportCannedResponse.id,\n      title: schema.supportCannedResponse.title,\n      body: schema.supportCannedResponse.body,\n    })\n    .from(schema.supportCannedResponse)\n    .where(eq(schema.supportCannedResponse.isActive, true))\n    .orderBy(asc(schema.supportCannedResponse.title)));\n}\n\n/** Create a template. */\nexport async function createCannedResponse(\n  title: string,\n  body: string,\n  actorId: string,\n): Promise<CannedResponse> {\n  const rows = await withTenantTx((tx) => tx\n    .insert(schema.supportCannedResponse)\n    .values({ title, body, createdBy: actorId, updatedBy: actorId })\n    .returning({\n      id: schema.supportCannedResponse.id,\n      title: schema.supportCannedResponse.title,\n      body: schema.supportCannedResponse.body,\n    }));\n  const row = rows[0];\n  if (!row) throw new Error('canned response insert returned no row');\n  return row;\n}\n\n/**\n * Edit a live template.\n *\n * Guarded on `is_active` so a retired template cannot be edited back into\n * circulation — a resurrection should be a deliberate new row, not a side\n * effect of fixing a typo.\n */\nexport async function updateCannedResponse(\n  id: string,\n  fields: { title?: string; body?: string },\n  actorId: string,\n): Promise<boolean> {\n  if (fields.title === undefined && fields.body === undefined) return false;\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportCannedResponse)\n    .set({\n      ...(fields.title !== undefined ? { title: fields.title } : {}),\n      ...(fields.body !== undefined ? { body: fields.body } : {}),\n      updatedBy: actorId,\n      updatedAt: new Date(),\n    })\n    .where(and(\n      eq(schema.supportCannedResponse.id, id),\n      eq(schema.supportCannedResponse.isActive, true),\n    ))\n    .returning({ id: schema.supportCannedResponse.id }));\n  return rows.length > 0;\n}\n\n/**\n * Retire a template.\n *\n * SOFT, because a retired template is still the explanation of what a past\n * reply said — deleting the row would leave old correspondence unaccountable\n * for its own wording.\n */\nexport async function deleteCannedResponse(id: string, actorId: string): Promise<boolean> {\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportCannedResponse)\n    .set({ isActive: false, updatedBy: actorId, updatedAt: new Date() })\n    .where(and(\n      eq(schema.supportCannedResponse.id, id),\n      eq(schema.supportCannedResponse.isActive, true),\n    ))\n    .returning({ id: schema.supportCannedResponse.id }));\n  return rows.length > 0;\n}\n\n// --- Support contacts -------------------------------------------------------\n\n/**\n * Live designated contacts across a set of orgs (an account subtree).\n *\n * Takes the whole scope in one query rather than per-org because the allowance\n * POOLS at the root: a person designated on a team spends the account's\n * allowance, so counting team-by-team and summing would be the same number by\n * accident and the wrong shape the moment pooling changes.\n */\nexport async function countActiveSupportContacts(orgIds: readonly string[]): Promise<number> {\n  // Callers pass the expanded SUBTREE for the pooled cap, or a single org to ask\n  // \"may a case raised here have an owner at all\". Both are legitimate; see\n  // `SupportEntitlement` in platform for which field is which.\n  if (orgIds.length === 0) return 0;\n  const rows = await withTenantTx((tx) => tx\n    .select({ n: sql<number>`count(*)::int` })\n    .from(schema.supportContact)\n    .where(and(\n      inArray(schema.supportContact.orgId, [...orgIds]),\n      eq(schema.supportContact.isActive, true),\n    )));\n  return rows[0]?.n ?? 0;\n}\n\n/**\n * Live contacts for the tenant owner picker.\n *\n * SCOPE IS THE CALLER'S CHOICE, and the default is ONE ORG. The allowance pools\n * subtree-wide, but ownership does not: a team reassigns a case only among its\n * OWN contacts, so a pooled allowance never turns into one team's cases being\n * readable by a sibling. Pass a single org id for the picker; pass the expanded\n * subtree only where the pooled CAP is the question (see\n * `countActiveSupportContacts`).\n *\n * Taking a list rather than a single id keeps that decision at the call site\n * instead of hiding it here — the two scopes answer differently and the wrong\n * one leaks cases across teams.\n */\nexport async function listActiveSupportContacts(\n  orgIds: readonly string[],\n): Promise<{ orgId: string; userId: string; isPremium: boolean }[]> {\n  if (orgIds.length === 0) return [];\n  return withTenantTx((tx) => tx\n    .select({\n      orgId: schema.supportContact.orgId,\n      userId: schema.supportContact.userId,\n      // Carried so the admin panel can show who is upgraded without a second\n      // query, and so the tenant owner picker can say which contacts carry 24x7.\n      isPremium: schema.supportContact.isPremium,\n    })\n    .from(schema.supportContact)\n    .where(and(\n      inArray(schema.supportContact.orgId, [...orgIds]),\n      eq(schema.supportContact.isActive, true),\n    )));\n}\n\n/**\n * Whether this user is a live designated contact in any org of the scope.\n *\n * Transfer validation must pass the case's OWN org, not the subtree: accepting a\n * sibling team's contact as a valid transfer target is exactly the cross-team\n * leak the own-org ownership rule exists to prevent.\n */\nexport async function isSupportContact(orgIds: readonly string[], userId: string): Promise<boolean> {\n  if (orgIds.length === 0) return false;\n  const rows = await withTenantTx((tx) => tx\n    .select({ id: schema.supportContact.id })\n    .from(schema.supportContact)\n    .where(and(\n      inArray(schema.supportContact.orgId, [...orgIds]),\n      eq(schema.supportContact.userId, userId),\n      eq(schema.supportContact.isActive, true),\n    ))\n    .limit(1));\n  return rows.length > 0;\n}\n\n/**\n * Designate a support contact.\n *\n * The CAP is not enforced here — the caller holds it, because the limit lives on\n * the Mongo org doc and this module only reaches Postgres. Mirrors how seats are\n * capped in platform rather than in the row writer.\n *\n * `support_contact_org_user_uq` is partial on `is_active = true`, so\n * re-designating someone previously revoked inserts a fresh row rather than\n * colliding — the revoked row stays as the record that they once held it.\n */\nexport async function designateSupportContact(\n  orgId: string,\n  userId: string,\n  designatedBy: string,\n  isPremium = false,\n): Promise<void> {\n  await withTenantTx(async (tx) => {\n    await tx.insert(schema.supportContact)\n      .values({ orgId, userId, designatedBy, isPremium })\n      .onConflictDoNothing();\n  });\n}\n\n/**\n * Live contacts in a scope that are UPGRADED to premium — the cap's counterpart.\n *\n * Counted separately from the baseline total because the two caps are separate:\n * an account holds N contacts (`supportContacts`) and upgrades M of them\n * (`supportPremiumContacts`), M ≤ N. Pooled over whatever scope the caller\n * passes, exactly like {@link countActiveSupportContacts} — subtree for the cap,\n * one org for an ownership question.\n */\nexport async function countPremiumSupportContacts(orgIds: readonly string[]): Promise<number> {\n  if (orgIds.length === 0) return 0;\n  const rows = await withTenantTx((tx) => tx\n    .select({ n: sql<number>`count(*)::int` })\n    .from(schema.supportContact)\n    .where(and(\n      inArray(schema.supportContact.orgId, [...orgIds]),\n      eq(schema.supportContact.isActive, true),\n      eq(schema.supportContact.isPremium, true),\n    )));\n  return rows[0]?.n ?? 0;\n}\n\n/**\n * Whether this user is a live PREMIUM contact in the scope.\n *\n * The case-open path reads this to decide which level to freeze onto a new case:\n * premium when the opener is upgraded, the account's baseline otherwise. Pass the\n * case's OWN org — the upgrade follows the person in the org that nominated\n * them, and a sibling team's upgrade is not this org's to spend.\n */\nexport async function isPremiumSupportContact(orgIds: readonly string[], userId: string): Promise<boolean> {\n  if (orgIds.length === 0) return false;\n  const rows = await withTenantTx((tx) => tx\n    .select({ id: schema.supportContact.id })\n    .from(schema.supportContact)\n    .where(and(\n      inArray(schema.supportContact.orgId, [...orgIds]),\n      eq(schema.supportContact.userId, userId),\n      eq(schema.supportContact.isActive, true),\n      eq(schema.supportContact.isPremium, true),\n    ))\n    .limit(1));\n  return rows.length > 0;\n}\n\n/**\n * Upgrade or downgrade a LIVE contact.\n *\n * Guarded on `is_active` so a revoked row cannot be upgraded back into\n * relevance, and returns whether a row actually moved — the caller counts\n * against the premium cap before calling, and a silent no-op would let that\n * count drift from reality.\n *\n * Deliberately does NOT touch the case rows: `support_case.level` is frozen at\n * open, so downgrading somebody never weakens a promise already made on a case\n * they raised while upgraded.\n */\nexport async function setSupportContactPremium(\n  orgId: string,\n  userId: string,\n  isPremium: boolean,\n): Promise<boolean> {\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportContact)\n    .set({ isPremium })\n    .where(and(\n      eq(schema.supportContact.orgId, orgId),\n      eq(schema.supportContact.userId, userId),\n      eq(schema.supportContact.isActive, true),\n    ))\n    .returning({ id: schema.supportContact.id }));\n  return rows.length > 0;\n}\n\n/**\n * Revoke a designation, freeing the slot.\n *\n * Returns the user's still-open cases so the caller can reassign them instead of\n * orphaning — scope C4's answer. Revoking is deliberately not blocked on them:\n * refusing to remove a departed employee because they still own cases would be\n * worse than handing the cases on.\n */\nexport async function revokeSupportContact(\n  orgId: string,\n  userId: string,\n  revokedBy: string,\n): Promise<{ revoked: boolean; openCases: SupportCase[] }> {\n  const openCases = await openCasesForContact(orgId, userId);\n  const rows = await withTenantTx((tx) => tx\n    .update(schema.supportContact)\n    .set({ isActive: false, revokedAt: new Date(), revokedBy })\n    .where(and(\n      eq(schema.supportContact.orgId, orgId),\n      eq(schema.supportContact.userId, userId),\n      eq(schema.supportContact.isActive, true),\n    ))\n    .returning({ id: schema.supportContact.id }));\n  return { revoked: rows.length > 0, openCases };\n}\n"]}