create-ailk 0.2.0 → 0.4.0

package/templates/apps/api/src/bin/deliverable-resend.ts

@@ -1,144 +0,0 @@
-#!/usr/bin/env node
-/* istanbul ignore file -- CLI bootstrap; mirrors abandon-sweep.ts's coverage-ignore
-   rationale — the underlying list/resend logic is unit-tested at the service
-   layer (services/__tests__/deliverable-resend.test.ts), through the same
-   mocked-prisma double the fulfillment service tests already use. This file
-   is a thin entry: parse args, dispatch to list or resend, print, set exit
-   code. */
-/**
- * Deliverable-grant resend CLI (#3998 D2/D4).
- *
- * Dev — list mode (read-only, default):
- *   `pnpm --filter @working-theory/api deliverable:resend -- --site <siteId>
- *   [--since <iso>] [--limit <n>]`
- * Dev — resend mode (one grant):
- *   `pnpm --filter @working-theory/api deliverable:resend -- --grant <grantId>`
- * Production: `node dist/bin/deliverable-resend.js <same flags>`.
- *
- * No HTTP resend route exists (spec §2.2/D2) — this CLI is the sole recovery
- * path for a grant whose post-mint send never completed, run by the operator
- * on their own machine/CI. List mode is the read-only default and can never
- * send anything. `--grant` is always a deliberate, named, single-grant act
- * (D4) — there is no bulk/`--all` mode; the operator loops over the list
- * output if several need resending.
- */
-import {
-  listSendlessGrants,
-  resendDeliverableGrant,
-} from "../services/deliverable-fulfillment.js";
-
-type ParsedArgs = {
-  site?: string | undefined;
-  since?: string | undefined;
-  limit?: string | undefined;
-  grant?: string | undefined;
-};
-
-/** Minimal `--flag value` parser — no external dependency for a 4-flag CLI. */
-function parseArgs(argv: string[]): ParsedArgs {
-  const out: ParsedArgs = {};
-  for (let i = 0; i < argv.length; i += 1) {
-    const flag = argv[i];
-    const value = argv[i + 1];
-    if (flag === "--site") out.site = value;
-    else if (flag === "--since") out.since = value;
-    else if (flag === "--limit") out.limit = value;
-    else if (flag === "--grant") out.grant = value;
-    else continue;
-    i += 1;
-  }
-  return out;
-}
-
-async function runResend(grantId: string): Promise<void> {
-  const result = await resendDeliverableGrant(grantId);
-
-  if (!result.ok) {
-    console.error(
-      `[deliverable-resend] ${result.error.kind}: ${result.error.message}`,
-    );
-    process.exitCode = 1;
-    return;
-  }
-
-  console.log(
-    `[deliverable-resend] grant="${grantId}" outcome="${result.outcome}"`,
-  );
-  if (result.outcome !== "sent") {
-    process.exitCode = 1;
-  }
-}
-
-async function runList(args: ParsedArgs): Promise<void> {
-  if (!args.site) {
-    console.error(
-      "[deliverable-resend] usage: --site <siteId> [--since <iso>] [--limit <n>]",
-    );
-    process.exitCode = 1;
-    return;
-  }
-
-  let since: Date | undefined;
-  if (args.since !== undefined) {
-    since = new Date(args.since);
-    if (Number.isNaN(since.getTime())) {
-      console.error(
-        `[deliverable-resend] invalid --since value: "${args.since}"`,
-      );
-      process.exitCode = 1;
-      return;
-    }
-  } else {
-    // D4: every historical (pre-migration) grant reads sendStatus IS NULL,
-    // so an unfiltered first run on an established site lists every grant
-    // ever minted — most of which were, in fact, delivered via the prior
-    // log-only path. The caveat is printed, not silently assumed away.
-    console.log(
-      "[deliverable-resend] no --since given — listing EVERY sendless grant " +
-        "for this site, including pre-migration rows that predate this " +
-        "column and may already have been delivered.",
-    );
-  }
-
-  let limit: number | undefined;
-  if (args.limit !== undefined) {
-    limit = Number.parseInt(args.limit, 10);
-    if (!Number.isInteger(limit) || limit <= 0) {
-      console.error(
-        `[deliverable-resend] invalid --limit value: "${args.limit}"`,
-      );
-      process.exitCode = 1;
-      return;
-    }
-  }
-
-  const rows = await listSendlessGrants({
-    siteId: args.site,
-    ...(since !== undefined && { since }),
-    ...(limit !== undefined && { limit }),
-  });
-
-  for (const row of rows) {
-    console.log(JSON.stringify(row));
-  }
-  console.log(`[deliverable-resend] ${rows.length} sendless grant(s)`);
-}
-
-async function main(): Promise<void> {
-  const args = parseArgs(process.argv.slice(2));
-
-  if (args.grant) {
-    await runResend(args.grant);
-  } else {
-    await runList(args);
-  }
-}
-
-main().catch((err: unknown) => {
-  // Belt-and-suspenders (mirrors abandon-sweep.ts) — an unexpected throw
-  // (a bad DB connection, etc.) still exits non-zero with a structured
-  // message rather than an unhandled-rejection crash.
-  const message = err instanceof Error ? err.message : "Unknown error";
-  console.error(`[deliverable-resend] unexpected_error: ${message}`);
-  process.exitCode = 1;
-});

package/templates/apps/api/src/bin/deliverable-upload.ts

@@ -1,114 +0,0 @@
-#!/usr/bin/env node
-/* istanbul ignore file -- CLI bootstrap; mirrors abandon-sweep.ts's coverage-ignore
-   rationale — real entry-point semantics run the compiled dist directly, and
-   the DB write it performs (prisma.deliverableAsset.upsert) is exercised
-   through the same mocked-prisma double the service-layer tests already use
-   (apps/api/src/lib/__mocks__/prisma.ts § deliverableAsset). This file is a
-   thin entry: parse args, read the file, refuse the size cap, upsert. */
-/**
- * Deliverable-asset upload CLI (#3961 D6).
- *
- * Dev: `pnpm --filter @working-theory/api deliverable:upload -- --site <siteId>
- * --key <key> --file <path> [--content-type <ct>] [--filename <name>]`.
- * Production: `node dist/bin/deliverable-upload.js <same flags>`.
- *
- * No HTTP upload route exists (spec §2.2) — this CLI is the sole write path
- * for `DeliverableAsset` rows, run by the operator on their own machine/CI,
- * never by a customer or agent request. Re-upload (same siteId + key)
- * REPLACES the stored bytes (upsert) — the config's `assetKey` reference
- * never changes, so a content update is a re-run of this command.
- *
- * The 20 MB cap is a CLI guard, not a schema constraint (Postgres `bytea`
- * has no practical limit at launch volumes) — it keeps the DB-storage
- * choice (D1) honest until the blob-storage upgrade path is taken.
- */
-import { readFileSync, statSync } from "node:fs";
-import { basename } from "node:path";
-
-import { prisma } from "../lib/prisma.js";
-
-const MAX_BYTES = 20 * 1024 * 1024; // 20 MB (D6)
-const DEFAULT_CONTENT_TYPE = "application/octet-stream";
-
-type ParsedArgs = {
-  siteId?: string | undefined;
-  key?: string | undefined;
-  file?: string | undefined;
-  contentType?: string | undefined;
-  filename?: string | undefined;
-};
-
-/** Minimal `--flag value` parser — no external dependency for a 5-flag CLI. */
-function parseArgs(argv: string[]): ParsedArgs {
-  const out: ParsedArgs = {};
-  for (let i = 0; i < argv.length; i += 1) {
-    const flag = argv[i];
-    const value = argv[i + 1];
-    if (flag === "--site") out.siteId = value;
-    else if (flag === "--key") out.key = value;
-    else if (flag === "--file") out.file = value;
-    else if (flag === "--content-type") out.contentType = value;
-    else if (flag === "--filename") out.filename = value;
-    else continue;
-    i += 1;
-  }
-  return out;
-}
-
-async function main(): Promise<void> {
-  const args = parseArgs(process.argv.slice(2));
-
-  if (!args.siteId || !args.key || !args.file) {
-    console.error(
-      "[deliverable-upload] usage: --site <siteId> --key <key> --file <path> " +
-        "[--content-type <ct>] [--filename <name>]",
-    );
-    process.exitCode = 1;
-    return;
-  }
-
-  const stat = statSync(args.file);
-  if (stat.size > MAX_BYTES) {
-    console.error(
-      `[deliverable-upload] refused: ${args.file} is ${stat.size} bytes, ` +
-        `exceeds the ${MAX_BYTES}-byte (20 MB) cap`,
-    );
-    process.exitCode = 1;
-    return;
-  }
-
-  const bytes = readFileSync(args.file);
-  const filename = args.filename ?? basename(args.file);
-  const contentType = args.contentType ?? DEFAULT_CONTENT_TYPE;
-
-  const row = await prisma.deliverableAsset.upsert({
-    where: { siteId_key: { siteId: args.siteId, key: args.key } },
-    create: {
-      siteId: args.siteId,
-      key: args.key,
-      filename,
-      contentType,
-      bytes,
-      size: stat.size,
-    },
-    update: {
-      filename,
-      contentType,
-      bytes,
-      size: stat.size,
-    },
-    select: { key: true },
-  });
-
-  console.log(`[deliverable-upload] uploaded key="${row.key}"`);
-}
-
-main().catch((err: unknown) => {
-  // Belt-and-suspenders (mirrors abandon-sweep.ts) — main() has no
-  // internal catch of its own, so an unexpected throw (a bad DB
-  // connection, a filesystem error mid-read) still exits non-zero with a
-  // structured message rather than an unhandled-rejection crash.
-  const message = err instanceof Error ? err.message : "Unknown error";
-  console.error(`[deliverable-upload] unexpected_error: ${message}`);
-  process.exitCode = 1;
-});

package/templates/apps/api/src/bin/followup-sweep.ts

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-/* istanbul ignore file -- CLI bootstrap; the underlying
-   runWaitlistFollowUpSweep logic is unit-tested in
-   services/__tests__/waitlist-followup.test.ts. Mirrors abandon-sweep.ts's
-   coverage-ignore rationale — real entry-point semantics run the compiled
-   dist directly, on the operator's own cron/scheduler cadence (D1: no
-   queue/timer infrastructure in this repo — an external scheduler runs this
-   command on whatever cadence the deployment chooses). */
-/**
- * Waitlist follow-up sweep CLI entry (#4732 D1).
- *
- * Dev: `pnpm --filter @working-theory/api followup:sweep` (tsx, this file).
- * Production: `node dist/bin/followup-sweep.js` (the compiled entry, run by
- * any external scheduler — Vercel Cron, GitHub Actions cron, plain crontab).
- * The sweep is stateless and idempotent (the `waitlist_followup_sends`
- * `@@unique([leadId, followUpKey])` guarantee), so overlap or a missed tick
- * is harmless — the offset window is data, not a timer.
- */
-import { runWaitlistFollowUpSweep } from "../services/waitlist-followup.js";
-
-async function main(): Promise<void> {
-  const result = await runWaitlistFollowUpSweep();
-
-  if (!result.ok) {
-    console.error(
-      `[followup-sweep] ${result.error.kind}: ${result.error.message}`,
-    );
-    process.exitCode = 1;
-    return;
-  }
-
-  console.log(`[followup-sweep] ${JSON.stringify(result.summary)}`);
-}
-
-main().catch((err: unknown) => {
-  // Belt-and-suspenders (mirrors abandon-sweep.ts): runWaitlistFollowUpSweep
-  // already catches internally and returns a structured `unexpected_error`
-  // result, so this path is unreachable in practice — it exists only to
-  // prevent a bare unhandled-rejection crash if `main` itself ever throws
-  // before/around that call.
-  const message = err instanceof Error ? err.message : "Unknown error";
-  console.error(`[followup-sweep] unexpected_error: ${message}`);
-  process.exitCode = 1;
-});

package/templates/apps/api/src/bin/listing-csv-sweep.ts

@@ -1,46 +0,0 @@
-#!/usr/bin/env node
-/* istanbul ignore file -- CLI bootstrap; the underlying runListingCsvSweep
-   logic is unit-tested in services/__tests__/listing-csv-sweep.test.ts.
-   Mirrors followup-sweep.ts's coverage-ignore rationale — real entry-point
-   semantics run the compiled dist directly, on the operator's own
-   cron/scheduler cadence (D1: no queue/timer infrastructure in this repo —
-   an external scheduler runs this command on whatever cadence the deployment
-   chooses). */
-/**
- * Weekly founder-CSV sweep CLI entry (#5001).
- *
- * Dev: `pnpm --filter @working-theory/api listing-csv:sweep` (tsx, this file).
- * Production: `node dist/bin/listing-csv-sweep.js` (the compiled entry, run by
- * any external scheduler — Vercel Cron, GitHub Actions cron, plain crontab).
- * The consumer schedules this WEEKLY; this repo adds no cron of its own.
- *
- * The sweep is stateless and idempotent: a listing with no `WaitlistScore`
- * newer than its last `ListingCsvSend` sends nothing, so an extra tick is a
- * no-op and a missed tick simply widens the next CSV's window.
- */
-import { runListingCsvSweep } from "../services/listing-csv-sweep.js";
-
-async function main(): Promise<void> {
-  const result = await runListingCsvSweep();
-
-  if (!result.ok) {
-    console.error(
-      `[listing-csv-sweep] ${result.error.kind}: ${result.error.message}`,
-    );
-    process.exitCode = 1;
-    return;
-  }
-
-  console.log(`[listing-csv-sweep] ${JSON.stringify(result.summary)}`);
-}
-
-main().catch((err: unknown) => {
-  // Belt-and-suspenders (mirrors followup-sweep.ts): runListingCsvSweep
-  // already catches internally and returns a structured `unexpected_error`
-  // result, so this path is unreachable in practice — it exists only to
-  // prevent a bare unhandled-rejection crash if `main` itself ever throws
-  // before/around that call.
-  const message = err instanceof Error ? err.message : "Unknown error";
-  console.error(`[listing-csv-sweep] unexpected_error: ${message}`);
-  process.exitCode = 1;
-});

package/templates/apps/api/src/bin/seed-presets.ts

@@ -1,58 +0,0 @@
-#!/usr/bin/env node
-/* istanbul ignore file -- CLI bootstrap; the underlying seedFlowPresets logic
-   is unit-tested in services/__tests__/flow-engine.test.ts. Mirrors
-   bin/abandon-sweep.ts's coverage-ignore rationale — real entry-point
-   semantics run the compiled dist directly. */
-/**
- * Flow-preset seed CLI entry (#3958 §3.3).
- *
- * Writes the three static capture presets (form, waitlist, lead-magnet —
- * `@working-theory/database/flows/presets`) through the existing validated
- * `upsertFlowDefinition` path, for the current site (`currentSiteId()`,
- * `lib/site.ts`) — the same site id the `/v1/flows/*` routes resolve against,
- * so a preset is never written somewhere the routes can't find it.
- *
- * Dev: `pnpm --filter @working-theory/api seed:presets` (tsx, this file).
- * Production: `node dist/bin/seed-presets.js` (the compiled entry, run once
- * per site by the operator — idempotent: `upsertFlowDefinition` upserts on
- * `[siteId, slug]`, so a re-run overwrites cleanly rather than duplicating).
- *
- * This entry point is the placement chosen for #3958's operator-facing
- * invocation (spec §3.3 / §7 item 1 — the implementer's choice, both
- * placements bounded and reversible): `apps/api/src/bin/` already hosts
- * exactly this shape of one-off operator command (`abandon-sweep.ts`), so it
- * is the closer fit to "the existing apps/api CLI surface" than adding
- * argv-verb parsing to `cli.ts`, which today does nothing but bootstrap the
- * long-running server.
- */
-import { FLOW_PRESETS } from "@working-theory/database/flows/presets";
-
-import { currentSiteId } from "../lib/site.js";
-import { seedFlowPresets } from "../services/flow-engine.js";
-
-async function main(): Promise<void> {
-  const siteId = currentSiteId();
-  const result = await seedFlowPresets(siteId, FLOW_PRESETS);
-
-  if (!result.ok) {
-    console.error(
-      `[seed-presets] ${result.error.kind}: ${result.error.message} (seeded before failure: ${result.seeded.join(", ") || "none"})`,
-    );
-    process.exitCode = 1;
-    return;
-  }
-
-  console.log(
-    `[seed-presets] seeded for site "${siteId}": ${result.seeded.join(", ")}`,
-  );
-}
-
-main().catch((err: unknown) => {
-  // Belt-and-suspenders, mirroring abandon-sweep.ts: seedFlowPresets already
-  // returns a structured failure rather than throwing, so this path exists
-  // only to prevent a bare unhandled-rejection crash if `main` itself ever
-  // throws before/around that call.
-  const message = err instanceof Error ? err.message : "Unknown error";
-  console.error(`[seed-presets] unexpected_error: ${message}`);
-  process.exitCode = 1;
-});

package/templates/apps/api/src/bin/seed-waitlist-experiments.ts

@@ -1,104 +0,0 @@
-#!/usr/bin/env node
-/* istanbul ignore file -- CLI bootstrap; the underlying seedWaitlistExperiments
-   logic is unit-tested in services/__tests__/waitlist-experiments.test.ts.
-   Mirrors bin/seed-presets.ts's coverage-ignore rationale. */
-/**
- * Waitlist-experiment seed CLI entry (#4661 D5).
- *
- * Reads one or more experiment-config JSON paths from argv, resolves any
- * `questionSetRef` / `scoringRef` / `sourceTrackingRef` path (relative to the
- * config file) into the embedded objects, and writes them through the
- * existing validated `seedWaitlistExperiments` path, for the current site
- * (`currentSiteId()`, `lib/site.ts`) — the same bootstrap shape as
- * `seed-presets.ts`.
- *
- * `seedWaitlistExperiments` does MORE than write `waitlist_experiments`
- * (#4726): for each config it also compiles + upserts one `flow_definitions`
- * row per `waitlists[]` entry (`materializeWaitlistFlows`,
- * `waitlist-experiments.ts`) — the step `GET /v1/flows/:flowSlug`
- * (`serveFlow`, `flow-engine.ts`) actually reads. A single run of this bin
- * is therefore sufficient to make every declared waitlist servable; a
- * compile failure (`unknown_waitlist` / `unsupported_by_engine`) or a
- * `flow_definitions` write failure exits this process non-zero, naming the
- * failing waitlist key, and writes no `flow_definitions` row for it.
- *
- * Dev: `pnpm --filter @working-theory/api tsx src/bin/seed-waitlist-experiments.ts <config.json>...`
- * Production: `node dist/bin/seed-waitlist-experiments.js <config.json>...` —
- * idempotent (`upsertWaitlistExperiment` upserts on `[siteId, key]`;
- * `upsertFlowDefinition` upserts on `[siteId, slug]`).
- */
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-
-import { currentSiteId } from "../lib/site.js";
-import { seedWaitlistExperiments } from "../services/waitlist-experiments.js";
-
-/**
- * A `*Ref` field on the config is a path RELATIVE to the config file (D5),
- * mapped to the embedded field name `waitlistExperimentConfigSchema`
- * actually declares. An EXPLICIT map, not a `Ref$` suffix strip —
- * `sourceTrackingRef` embeds as `tracking` (not `sourceTracking`), which a
- * generic strip gets wrong (code-review finding, #4661).
- */
-const REF_FIELD_MAP: Record<string, string> = {
-  questionSetRef: "questionSet",
-  scoringRef: "scoring",
-  sourceTrackingRef: "tracking",
-};
-
-function readJson(path: string): unknown {
-  return JSON.parse(readFileSync(path, "utf8"));
-}
-
-/**
- * Resolve every `*Ref` path on a raw config object relative to `configPath`
- * into the embedded object it names, mirroring the site-plan projection's
- * config-time `*Ref` convention (D5/D7) — the runtime never reads these
- * paths; this bin resolves them once, at seed time.
- */
-function resolveConfigRefs(raw: unknown, configPath: string): unknown {
-  if (typeof raw !== "object" || raw === null) return raw;
-  const resolved: Record<string, unknown> = { ...(raw as Record<string, unknown>) };
-  const base = dirname(configPath);
-  for (const [field, embeddedField] of Object.entries(REF_FIELD_MAP)) {
-    const value = resolved[field];
-    if (typeof value === "string") {
-      resolved[embeddedField] = readJson(resolve(base, value));
-      delete resolved[field];
-    }
-  }
-  return resolved;
-}
-
-async function main(): Promise<void> {
-  const configPaths = process.argv.slice(2);
-  if (configPaths.length === 0) {
-    console.error("[seed-waitlist-experiments] usage: <config.json>...");
-    process.exitCode = 1;
-    return;
-  }
-
-  const siteId = currentSiteId();
-  const configs = configPaths.map((path) =>
-    resolveConfigRefs(readJson(path), path),
-  );
-  const result = await seedWaitlistExperiments(siteId, configs);
-
-  if (!result.ok) {
-    console.error(
-      `[seed-waitlist-experiments] ${result.error.kind}: ${result.error.message} (seeded before failure: ${result.seeded.join(", ") || "none"})`,
-    );
-    process.exitCode = 1;
-    return;
-  }
-
-  console.log(
-    `[seed-waitlist-experiments] seeded for site "${siteId}": ${result.seeded.join(", ")}`,
-  );
-}
-
-main().catch((err: unknown) => {
-  const message = err instanceof Error ? err.message : "Unknown error";
-  console.error(`[seed-waitlist-experiments] unexpected_error: ${message}`);
-  process.exitCode = 1;
-});

package/templates/apps/api/src/bin/session-retention-sweep.ts

@@ -1,46 +0,0 @@
-#!/usr/bin/env node
-/* istanbul ignore file -- CLI bootstrap; the underlying cleanupAbandonedSessions
-   logic is unit-tested in services/__tests__/flow-engine.test.ts. Mirrors
-   abandon-sweep.ts's coverage-ignore rationale — real entry-point semantics
-   run the compiled dist directly, on the operator's own cron/scheduler
-   cadence (no queue/timer infrastructure in this repo — an external
-   scheduler runs this command on whatever cadence the deployment
-   chooses). */
-/**
- * FlowSession retention/cleanup sweep CLI entry (#3974 AC3).
- *
- * Dev: `pnpm --filter @working-theory/api retention:sweep` (tsx, this file).
- * Production: `node dist/bin/session-retention-sweep.js` (the compiled
- * entry, run by any external scheduler — Vercel Cron, GitHub Actions cron,
- * plain crontab). Deletes abandoned FlowSession rows past the retention
- * window (default 90 days) — see `cleanupAbandonedSessions`'s own doc
- * comment in ../services/flow-engine.ts for the full policy + its #3962
- * abandon-email coordination.
- */
-import { cleanupAbandonedSessions } from "../services/flow-engine.js";
-
-async function main(): Promise<void> {
-  const result = await cleanupAbandonedSessions();
-
-  if (!result.ok) {
-    console.error(
-      `[session-retention-sweep] ${result.error.kind}: ${result.error.message}`,
-    );
-    process.exitCode = 1;
-    return;
-  }
-
-  console.log(`[session-retention-sweep] deleted=${result.deleted}`);
-}
-
-main().catch((err: unknown) => {
-  // cleanupAbandonedSessions only returns a structured error for the
-  // DB-not-configured case (requireDb's guard) — a genuine prisma/DB
-  // exception propagates as a rejected promise, exactly like every other
-  // flow-engine.ts function (none of them wrap unexpected DB errors
-  // internally). This is that failure's landing spot, so it degrades to a
-  // clean process-exit rather than a bare unhandled-rejection crash.
-  const message = err instanceof Error ? err.message : "Unknown error";
-  console.error(`[session-retention-sweep] unexpected_error: ${message}`);
-  process.exitCode = 1;
-});

package/templates/apps/api/src/lib/__tests__/stripe.test.ts

@@ -1,74 +0,0 @@
-/**
- * apps/api stripe shim — surface-drift smoke tests.
- *
- * Ensures apps/api/src/lib/stripe.ts re-exports exactly what
- * @working-theory/stripe-client exports, with no surface drift.
- */
-
-jest.mock("@working-theory/stripe-client", () => ({
-  getStripeClient: jest.fn(),
-  assertSandboxKey: jest.fn(),
-  verifyWebhookSignature: jest.fn(),
-  createCheckoutSession: jest.fn(),
-  STRIPE_API_VERSION: "2023-10-16",
-  WEBHOOK_TOLERANCE_SECONDS: 300,
-  StripeConfigError: class StripeConfigError extends Error {},
-  StripeWebhookSignatureError: class StripeWebhookSignatureError extends Error {},
-  UnknownProductCodeError: class UnknownProductCodeError extends Error {},
-}));
-
-// Import the shim (not the wrapper directly)
-import * as stripeShim from "../stripe.js";
-import * as stripeClient from "@working-theory/stripe-client";
-
-describe("apps/api/src/lib/stripe — surface re-exports", () => {
-  it("exports getStripeClient as a function", () => {
-    expect(typeof stripeShim.getStripeClient).toBe("function");
-  });
-
-  it("exports assertSandboxKey as a function", () => {
-    expect(typeof stripeShim.assertSandboxKey).toBe("function");
-  });
-
-  it("exports verifyWebhookSignature as a function", () => {
-    expect(typeof stripeShim.verifyWebhookSignature).toBe("function");
-  });
-
-  it("exports createCheckoutSession as a function", () => {
-    expect(typeof stripeShim.createCheckoutSession).toBe("function");
-  });
-
-  it("exports STRIPE_API_VERSION", () => {
-    expect(stripeShim.STRIPE_API_VERSION).toBe("2023-10-16");
-  });
-
-  it("exports WEBHOOK_TOLERANCE_SECONDS", () => {
-    expect(stripeShim.WEBHOOK_TOLERANCE_SECONDS).toBe(300);
-  });
-
-  it("exports StripeConfigError as a constructor producing Error instances", () => {
-    expect(typeof stripeShim.StripeConfigError).toBe("function");
-    expect(new stripeShim.StripeConfigError()).toBeInstanceOf(Error);
-  });
-
-  it("exports StripeWebhookSignatureError as a constructor producing Error instances", () => {
-    expect(typeof stripeShim.StripeWebhookSignatureError).toBe("function");
-    expect(new stripeShim.StripeWebhookSignatureError()).toBeInstanceOf(Error);
-  });
-
-  it("exports UnknownProductCodeError as a constructor producing Error instances", () => {
-    expect(typeof stripeShim.UnknownProductCodeError).toBe("function");
-    expect(new stripeShim.UnknownProductCodeError()).toBeInstanceOf(Error);
-  });
-
-  it("shim functions are the same references as @working-theory/stripe-client exports", () => {
-    expect(stripeShim.getStripeClient).toBe(stripeClient.getStripeClient);
-    expect(stripeShim.assertSandboxKey).toBe(stripeClient.assertSandboxKey);
-    expect(stripeShim.verifyWebhookSignature).toBe(
-      stripeClient.verifyWebhookSignature,
-    );
-    expect(stripeShim.createCheckoutSession).toBe(
-      stripeClient.createCheckoutSession,
-    );
-  });
-});

package/templates/apps/api/src/lib/stripe.ts

@@ -1,52 +0,0 @@
-/**
- * apps/api Stripe shim.
- *
- * Re-exports @working-theory/stripe-client's public surface for use by routes and
- * services under apps/api. This is the SOLE Stripe-touching file in apps/api.
- *
- * Future routes import from here (`from '../lib/stripe'`), not directly from
- * '@working-theory/stripe-client' — single chokepoint for AILK-internal ergonomics
- * (logger context, request-id propagation) without touching every consumer.
- */
-import { getStripeClient } from "@working-theory/stripe-client";
-
-export {
-  assertSandboxKey,
-  createBillingPortalSession,
-  createCheckoutSession,
-  createQuotedCheckoutSession,
-  getStripeClient,
-  STRIPE_API_VERSION,
-  StripeConfigError,
-  StripeWebhookSignatureError,
-  UnknownProductCodeError,
-  verifyWebhookSignature,
-  WEBHOOK_TOLERANCE_SECONDS,
-} from "@working-theory/stripe-client";
-
-export type {
-  CreateBillingPortalSessionInput,
-  CreateBillingPortalSessionOutput,
-  CreateCheckoutSessionInput,
-  CreateCheckoutSessionOutput,
-  CreateCheckoutSessionParams,
-  CreateQuotedCheckoutSessionInput,
-  CreateQuotedCheckoutSessionOutput,
-  Stripe,
-  StripeCheckoutSession,
-  StripeWebhookEvent,
-} from "@working-theory/stripe-client";
-
-/**
- * Expire a Checkout Session (#4912 FR7/D7).
- *
- * The compensation the recommender's attach-miss branch owes: the Stripe
- * session already exists, its id never reached the `FlowCheckout` row, and
- * nothing will ever join the two — so the session is closed rather than left
- * live and payable (#4863). Built on the already-re-exported
- * `getStripeClient`, whose construction asserts the `sk_test_` allow-list, so
- * this call inherits the test-mode gate like every other Stripe call here.
- */
-export async function expireCheckoutSession(stripeSessionId: string): Promise<void> {
-  await getStripeClient().checkout.sessions.expire(stripeSessionId);
-}