@ysk-kit/cli 1.0.0

package/templates/capabilities/billing/apps/api/src/modules/billing/infra/billing.app.test.ts

@@ -0,0 +1,273 @@
+import { createHmac } from 'node:crypto';
+import request from 'supertest';
+import { describe, expect, it } from 'vitest';
+import { createApp } from '../../../app';
+import { createMemoryInput } from '../../../create-memory-input';
+import { createBillingService } from '../application/billing-service';
+import { createLogBilling } from './log-billing';
+import { createMemorySubscriptionRepository } from './memory-subscription-repository';
+import { createStripeBilling } from './stripe-billing';
+
+describe('billing http', () => {
+  it('includes plans in OpenAPI', async () => {
+    const app = createApp(createMemoryInput().input);
+    const spec = await request(app).get('/openapi.json');
+    expect(spec.body.paths['/v1/billing/plans']).toBeDefined();
+  });
+
+  it('activates a subscription from a signed Stripe webhook', async () => {
+    const mem = createMemoryInput();
+    const app = createApp(mem.input);
+    const missing = await request(app).post('/v1/billing/webhook').send({});
+    expect(missing.status).toBe(404);
+    const secret = 'whsec_test';
+    const stripeApp = createApp({ ...mem.input, stripeWebhookSecret: secret });
+    const registered = await request(stripeApp).post('/v1/auth/register').send({
+      email: 'stripe@ysk.hk',
+      password: 'password1',
+      displayName: 'Stripe',
+    });
+    const jwt = registered.body.data.accessToken as string;
+    const org = await request(stripeApp)
+      .post('/v1/organizations')
+      .set('authorization', `Bearer ${jwt}`)
+      .send({ name: 'Pay' });
+    const organizationId = org.body.data.id as string;
+    const payload = JSON.stringify({
+      type: 'checkout.session.completed',
+      data: {
+        object: {
+          customer: 'cus_1',
+          metadata: { organizationId, planCode: 'pro', seatCount: '2' },
+        },
+      },
+    });
+    const unsigned = await request(stripeApp)
+      .post('/v1/billing/webhook')
+      .set('content-type', 'application/json')
+      .send(payload);
+    expect(unsigned.status).toBe(401);
+    const t = String(Math.floor(Date.now() / 1000));
+    const v1 = createHmac('sha256', secret).update(`${t}.${payload}`).digest('hex');
+    const signed = await request(stripeApp)
+      .post('/v1/billing/webhook')
+      .set('content-type', 'application/json')
+      .set('stripe-signature', `t=${t},v1=${v1}`)
+      .send(payload);
+    expect(signed.status).toBe(200);
+    const sub = await request(stripeApp)
+      .get(`/v1/billing/subscription?organizationId=${organizationId}`)
+      .set('authorization', `Bearer ${jwt}`);
+    expect(sub.body.data.planCode).toBe('pro');
+    expect(sub.body.data.status).toBe('active');
+    expect(sub.body.data.seatCount).toBe(2);
+  });
+
+  it('rejects Stripe portal before a customer exists', async () => {
+    const mem = createMemoryInput();
+    const billingService = createBillingService({
+      subscriptions: createMemorySubscriptionRepository(),
+      billing: createStripeBilling({
+        secretKey: 'sk_test_x',
+        pricePro: 'price_pro',
+        fetchImpl: (async () => new Response('{}', { status: 500 })) as typeof fetch,
+      }),
+      orgs: mem.orgs,
+    });
+    const stripeApp = createApp({ ...mem.input, billingService });
+    const registered = await request(stripeApp).post('/v1/auth/register').send({
+      email: 'portal@ysk.hk',
+      password: 'password1',
+      displayName: 'Portal',
+    });
+    const jwt = registered.body.data.accessToken as string;
+    const org = await request(stripeApp)
+      .post('/v1/organizations')
+      .set('authorization', `Bearer ${jwt}`)
+      .send({ name: 'Portal Co' });
+    const denied = await request(stripeApp)
+      .post('/v1/billing/portal')
+      .set('authorization', `Bearer ${jwt}`)
+      .send({
+        organizationId: org.body.data.id,
+        returnUrl: 'http://localhost:5173/billing',
+      });
+    expect(denied.status).toBe(409);
+  });
+
+  it('lists plans publicly and checks out a pro subscription', async () => {
+    const mem = createMemoryInput();
+    const app = createApp(mem.input);
+    const plans = await request(app).get('/v1/billing/plans');
+    expect(plans.status).toBe(200);
+    expect(plans.body.data.some((row: { code: string }) => row.code === 'pro')).toBe(true);
+    const denied = await request(app).post('/v1/billing/checkout').send({
+      organizationId: '11111111-1111-4111-8111-111111111111',
+      planCode: 'pro',
+      successUrl: 'http://localhost:5173/ok',
+      cancelUrl: 'http://localhost:5173/no',
+    });
+    expect(denied.status).toBe(401);
+    const registered = await request(app).post('/v1/auth/register').send({
+      email: 'pay@ysk.hk',
+      password: 'password1',
+      displayName: 'Pay',
+    });
+    const jwt = registered.body.data.accessToken as string;
+    const org = await request(app)
+      .post('/v1/organizations')
+      .set('authorization', `Bearer ${jwt}`)
+      .send({ name: 'Pay Co' });
+    const organizationId = org.body.data.id as string;
+    const me = await request(app)
+      .get(`/v1/billing/subscription?organizationId=${organizationId}`)
+      .set('authorization', `Bearer ${jwt}`);
+    expect(me.body.data.planCode).toBe('free');
+    expect(me.body.data.seatCount).toBe(1);
+    const tooFewSeats = await request(app)
+      .post('/v1/billing/checkout')
+      .set('authorization', `Bearer ${jwt}`)
+      .send({
+        organizationId,
+        planCode: 'pro',
+        successUrl: 'http://localhost:5173/ok',
+        cancelUrl: 'http://localhost:5173/no',
+        seatCount: 0,
+      });
+    expect(tooFewSeats.status).toBe(422);
+    const checkout = await request(app)
+      .post('/v1/billing/checkout')
+      .set('authorization', `Bearer ${jwt}`)
+      .send({
+        organizationId,
+        planCode: 'pro',
+        successUrl: 'http://localhost:5173/ok',
+        cancelUrl: 'http://localhost:5173/no',
+        seatCount: 2,
+      });
+    expect(checkout.status).toBe(200);
+    expect(checkout.body.data.url).toContain('plan=pro');
+    expect(checkout.body.data.url).toContain('seats=2');
+    const sub = await request(app)
+      .get(`/v1/billing/subscription?organizationId=${organizationId}`)
+      .set('authorization', `Bearer ${jwt}`);
+    expect(sub.body.data.planCode).toBe('pro');
+    expect(sub.body.data.status).toBe('active');
+    expect(sub.body.data.seatCount).toBe(2);
+    const canceled = await request(app)
+      .post('/v1/billing/cancel')
+      .set('authorization', `Bearer ${jwt}`)
+      .send({ organizationId });
+    expect(canceled.status).toBe(200);
+    const after = await request(app)
+      .get(`/v1/billing/subscription?organizationId=${organizationId}`)
+      .set('authorization', `Bearer ${jwt}`);
+    expect(after.body.data.status).toBe('canceled');
+    const portal = await request(app)
+      .post('/v1/billing/portal')
+      .set('authorization', `Bearer ${jwt}`)
+      .send({ organizationId, returnUrl: 'http://localhost:5173/billing' });
+    expect(portal.status).toBe(200);
+    expect(portal.body.data.url).toContain('billing.local/portal');
+    const invoices = await request(app)
+      .get(`/v1/billing/invoices?organizationId=${organizationId}`)
+      .set('authorization', `Bearer ${jwt}`);
+    expect(invoices.status).toBe(200);
+    expect(invoices.body.data).toEqual([]);
+    const pdf = await request(app)
+      .get(`/v1/billing/invoices/in_missing/pdf?organizationId=${organizationId}`)
+      .set('authorization', `Bearer ${jwt}`)
+      .redirects(0);
+    expect(pdf.status).toBe(404);
+  });
+
+  it('forbids org MEMBER checkout and rejects seatCount below members', async () => {
+    const mem = createMemoryInput();
+    const app = createApp(mem.input);
+    const ownerRes = await request(app).post('/v1/auth/register').send({
+      email: 'bill-owner@ysk.hk',
+      password: 'password1',
+      displayName: 'Owner',
+    });
+    await request(app).post('/v1/auth/register').send({
+      email: 'bill-member@ysk.hk',
+      password: 'password1',
+      displayName: 'Member',
+    });
+    const ownerToken = ownerRes.body.data.accessToken as string;
+    const org = await request(app)
+      .post('/v1/organizations')
+      .set('authorization', `Bearer ${ownerToken}`)
+      .send({ name: 'Seats Co' });
+    const organizationId = org.body.data.id as string;
+    await request(app)
+      .post(`/v1/organizations/${organizationId}/invites`)
+      .set('authorization', `Bearer ${ownerToken}`)
+      .send({ email: 'bill-member@ysk.hk', role: 'MEMBER' });
+    const inviteJob = mem.jobs.find(
+      (job) => job.name === 'email.send' && job.payload.vars?.inviteUrl,
+    );
+    const inviteToken = new URL(inviteJob?.payload.vars?.inviteUrl ?? 'http://x').searchParams.get(
+      'token',
+    );
+    await request(app).post('/v1/organizations/invites/accept').send({ token: inviteToken });
+    const memberLogin = await request(app).post('/v1/auth/login').send({
+      email: 'bill-member@ysk.hk',
+      password: 'password1',
+    });
+    const memberDenied = await request(app)
+      .post('/v1/billing/checkout')
+      .set('authorization', `Bearer ${memberLogin.body.data.accessToken}`)
+      .send({
+        organizationId,
+        planCode: 'pro',
+        successUrl: 'http://localhost:5173/ok',
+        cancelUrl: 'http://localhost:5173/no',
+        seatCount: 2,
+      });
+    expect(memberDenied.status).toBe(403);
+    const tooFew = await request(app)
+      .post('/v1/billing/checkout')
+      .set('authorization', `Bearer ${ownerToken}`)
+      .send({
+        organizationId,
+        planCode: 'pro',
+        successUrl: 'http://localhost:5173/ok',
+        cancelUrl: 'http://localhost:5173/no',
+        seatCount: 1,
+      });
+    expect(tooFew.status).toBe(422);
+  });
+
+  it('redirects to an invoice PDF when the port returns a URL', async () => {
+    const mem = createMemoryInput();
+    const log = createLogBilling();
+    const billingService = createBillingService({
+      subscriptions: createMemorySubscriptionRepository(),
+      billing: {
+        checkout: (input) => log.checkout(input),
+        portal: (input) => log.portal(input),
+        listInvoices: (input) => log.listInvoices(input),
+        getInvoicePdf: async () => ({ url: 'https://files.stripe.com/x.pdf' }),
+      },
+      orgs: mem.orgs,
+    });
+    const pdfApp = createApp({ ...mem.input, billingService });
+    const registered = await request(pdfApp).post('/v1/auth/register').send({
+      email: 'pdf@ysk.hk',
+      password: 'password1',
+      displayName: 'Pdf',
+    });
+    const org = await mem.orgs.createWithOwner({
+      name: 'Pdf Co',
+      ownerUserId: registered.body.data.user.id as string,
+    });
+    await billingService.activate(org.id, 'pro', 'cus_1', 1);
+    const pdf = await request(pdfApp)
+      .get(`/v1/billing/invoices/in_1/pdf?organizationId=${org.id}`)
+      .set('authorization', `Bearer ${registered.body.data.accessToken}`)
+      .redirects(0);
+    expect(pdf.status).toBe(302);
+    expect(pdf.headers.location).toBe('https://files.stripe.com/x.pdf');
+  });
+});

package/templates/capabilities/billing/apps/api/src/modules/billing/infra/log-billing.ts

@@ -0,0 +1,31 @@
+import type { IBillingPort } from '../domain/billing-port';
+
+export const createLogBilling = (
+  sink: Array<{
+    organizationId: string;
+    planCode: string;
+    seatCount: number;
+    urlSuffix: string;
+  }> = [],
+): IBillingPort & { sink: typeof sink } => ({
+  sink,
+  async checkout(input) {
+    const url = `https://billing.local/checkout?plan=${encodeURIComponent(input.planCode)}&seats=${input.seatCount}`;
+    sink.push({
+      organizationId: input.organizationId,
+      planCode: input.planCode,
+      seatCount: input.seatCount,
+      urlSuffix: url.slice(-12),
+    });
+    return { url };
+  },
+  async portal() {
+    return { url: 'https://billing.local/portal' };
+  },
+  async listInvoices() {
+    return [];
+  },
+  async getInvoicePdf() {
+    return null;
+  },
+});

package/templates/capabilities/billing/apps/api/src/modules/billing/infra/memory-subscription-repository.ts

@@ -0,0 +1,27 @@
+import type {
+  ISubscriptionRepository,
+  SubscriptionRecord,
+} from '../domain/subscription-repository';
+
+export const createMemorySubscriptionRepository = (): ISubscriptionRepository => {
+  const rows = new Map<string, SubscriptionRecord>();
+  return {
+    async findByOrganizationId(organizationId) {
+      return rows.get(organizationId) ?? null;
+    },
+    async upsert(input) {
+      const existing = rows.get(input.organizationId);
+      const row: SubscriptionRecord = {
+        id: existing?.id ?? crypto.randomUUID(),
+        createdAt: existing?.createdAt ?? new Date(),
+        organizationId: input.organizationId,
+        planCode: input.planCode,
+        status: input.status,
+        currentPeriodEnd: input.currentPeriodEnd,
+        seatCount: input.seatCount,
+      };
+      rows.set(input.organizationId, row);
+      return row;
+    },
+  };
+};

package/templates/capabilities/billing/apps/api/src/modules/billing/infra/prisma-subscription-repository.ts

@@ -0,0 +1,52 @@
+import type { BillingPlanCode, SubscriptionStatus } from '@ysk-kit/contracts';
+import type { PrismaClient } from '../../../generated/prisma/client';
+import type {
+  ISubscriptionRepository,
+  SubscriptionRecord,
+} from '../domain/subscription-repository';
+
+const toRecord = (row: {
+  id: string;
+  organizationId: string;
+  planCode: string;
+  status: string;
+  currentPeriodEnd: Date | null;
+  seatCount: number;
+  createdAt: Date;
+}): SubscriptionRecord => ({
+  id: row.id,
+  organizationId: row.organizationId,
+  planCode: row.planCode as BillingPlanCode,
+  status: row.status as SubscriptionStatus,
+  currentPeriodEnd: row.currentPeriodEnd,
+  seatCount: row.seatCount,
+  createdAt: row.createdAt,
+});
+
+export const createPrismaSubscriptionRepository = (
+  prisma: PrismaClient,
+): ISubscriptionRepository => ({
+  async findByOrganizationId(organizationId) {
+    const row = await prisma.subscription.findUnique({ where: { organizationId } });
+    return row ? toRecord(row) : null;
+  },
+  async upsert(input) {
+    const row = await prisma.subscription.upsert({
+      where: { organizationId: input.organizationId },
+      create: {
+        organizationId: input.organizationId,
+        planCode: input.planCode,
+        status: input.status,
+        currentPeriodEnd: input.currentPeriodEnd,
+        seatCount: input.seatCount,
+      },
+      update: {
+        planCode: input.planCode,
+        status: input.status,
+        currentPeriodEnd: input.currentPeriodEnd,
+        seatCount: input.seatCount,
+      },
+    });
+    return toRecord(row);
+  },
+});

package/templates/capabilities/billing/apps/api/src/modules/billing/infra/stripe-billing.test.ts

@@ -0,0 +1,127 @@
+import { createHmac } from 'node:crypto';
+import { describe, expect, it } from 'vitest';
+import { createStripeBilling, verifyStripeSignature } from './stripe-billing';
+
+describe('stripe billing', () => {
+  it('creates a pending checkout session', async () => {
+    const bodies: string[] = [];
+    const billing = createStripeBilling({
+      secretKey: 'sk_test_x',
+      pricePro: 'price_pro_1',
+      fetchImpl: (async (url, init) => {
+        bodies.push(String(init?.body));
+        expect(String(url)).toContain('/v1/checkout/sessions');
+        const headers = (init?.headers ?? {}) as { authorization?: string };
+        expect(headers.authorization).toBe('Bearer sk_test_x');
+        return new Response(JSON.stringify({ url: 'https://checkout.stripe.com/c/pay/cs_test' }), {
+          status: 200,
+        });
+      }) as typeof fetch,
+    });
+    const result = await billing.checkout({
+      organizationId: '11111111-1111-4111-8111-111111111111',
+      planCode: 'pro',
+      successUrl: 'https://app.example/ok',
+      cancelUrl: 'https://app.example/no',
+      seatCount: 3,
+    });
+    expect(result.url).toContain('checkout.stripe.com');
+    expect(result.pending).toBe(true);
+    expect(bodies[0]).toContain('price_pro_1');
+    expect(bodies[0]).toContain('11111111-1111-4111-8111-111111111111');
+    expect(bodies[0]).toContain('line_items%5B0%5D%5Bquantity%5D=3');
+    expect(bodies[0]).toContain('automatic_tax%5Benabled%5D=true');
+    expect(bodies[0]).toContain('billing_address_collection=required');
+  });
+
+  it('opens a billing portal session', async () => {
+    const bodies: string[] = [];
+    const billing = createStripeBilling({
+      secretKey: 'sk_test_x',
+      pricePro: 'price_pro_1',
+      fetchImpl: (async (_url, init) => {
+        bodies.push(String(init?.body));
+        return new Response(JSON.stringify({ url: 'https://billing.stripe.com/p/session' }), {
+          status: 200,
+        });
+      }) as typeof fetch,
+    });
+    const result = await billing.portal({
+      returnUrl: 'https://app.example/billing',
+      customerId: 'cus_123',
+    });
+    expect(result.url).toContain('billing.stripe.com');
+    expect(bodies[0]).toContain('cus_123');
+  });
+
+  it('maps Stripe invoices', async () => {
+    const billing = createStripeBilling({
+      secretKey: 'sk_test_x',
+      pricePro: 'price_pro_1',
+      fetchImpl: (async (url) => {
+        expect(String(url)).toContain('customer=cus_123');
+        return new Response(
+          JSON.stringify({
+            data: [
+              {
+                id: 'in_1',
+                number: 'ABC-1',
+                status: 'paid',
+                amount_due: 9900,
+                currency: 'hkd',
+                hosted_invoice_url: 'https://invoice.stripe.com/i/1',
+                created: 1_700_000_000,
+              },
+            ],
+          }),
+          { status: 200 },
+        );
+      }) as typeof fetch,
+    });
+    const rows = await billing.listInvoices({ customerId: 'cus_123' });
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.id).toBe('in_1');
+    expect(rows[0]?.amountDue).toBe(9900);
+    expect(rows[0]?.hostedInvoiceUrl).toContain('invoice.stripe.com');
+  });
+
+  it('returns invoice_pdf when the customer matches', async () => {
+    const billing = createStripeBilling({
+      secretKey: 'sk_test_x',
+      pricePro: 'price_pro_1',
+      fetchImpl: (async () =>
+        new Response(
+          JSON.stringify({
+            customer: 'cus_123',
+            invoice_pdf: 'https://files.stripe.com/invoices/in_1.pdf',
+          }),
+          { status: 200 },
+        )) as typeof fetch,
+    });
+    await expect(
+      billing.getInvoicePdf({ customerId: 'cus_123', invoiceId: 'in_1' }),
+    ).resolves.toEqual({ url: 'https://files.stripe.com/invoices/in_1.pdf' });
+    await expect(
+      billing.getInvoicePdf({ customerId: 'cus_other', invoiceId: 'in_1' }),
+    ).resolves.toBeNull();
+  });
+
+  it('verifies Stripe-Signature', () => {
+    const secret = 'whsec_test';
+    const payload = Buffer.from(
+      JSON.stringify({
+        type: 'checkout.session.completed',
+        data: { object: { metadata: { organizationId: 'o1', planCode: 'pro', seatCount: '2' } } },
+      }),
+    );
+    const t = '1700000000';
+    const v1 = createHmac('sha256', secret)
+      .update(`${t}.${payload.toString('utf8')}`)
+      .digest('hex');
+    const event = verifyStripeSignature(payload, `t=${t},v1=${v1}`, secret, 1_700_000_000_000);
+    expect(event.type).toBe('checkout.session.completed');
+    expect(() =>
+      verifyStripeSignature(payload, `t=${t},v1=dead`, secret, 1_700_000_000_000),
+    ).toThrow();
+  });
+});

package/templates/capabilities/billing/apps/api/src/modules/billing/infra/stripe-billing.ts

@@ -0,0 +1,160 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import type { InvoiceDto } from '@ysk-kit/contracts';
+import { AppError } from '@ysk-kit/domain-kernel';
+import type { IBillingPort } from '../domain/billing-port';
+
+export const verifyStripeSignature = (
+  raw: Buffer,
+  header: string,
+  secret: string,
+  nowMs = Date.now(),
+): {
+  type: string;
+  data: { object: { metadata?: Record<string, string>; customer?: string } };
+} => {
+  const parts = Object.fromEntries(
+    header.split(',').map((item) => {
+      const [key, ...rest] = item.split('=');
+      return [key ?? '', rest.join('=')];
+    }),
+  );
+  const timestamp = parts.t;
+  const signature = parts.v1;
+  if (!timestamp || !signature) throw new AppError('UNAUTHENTICATED', 'Invalid Stripe signature');
+  const age = Math.abs(nowMs - Number(timestamp) * 1000);
+  if (Number.isNaN(Number(timestamp)) || age > 5 * 60 * 1000) {
+    throw new AppError('UNAUTHENTICATED', 'Invalid Stripe signature');
+  }
+  const expected = createHmac('sha256', secret)
+    .update(`${timestamp}.${raw.toString('utf8')}`)
+    .digest('hex');
+  const a = Buffer.from(signature);
+  const b = Buffer.from(expected);
+  if (a.length !== b.length || !timingSafeEqual(a, b)) {
+    throw new AppError('UNAUTHENTICATED', 'Invalid Stripe signature');
+  }
+  return JSON.parse(raw.toString('utf8')) as {
+    type: string;
+    data: { object: { metadata?: Record<string, string>; customer?: string } };
+  };
+};
+
+export const createStripeBilling = (opts: {
+  secretKey: string;
+  pricePro: string;
+  fetchImpl?: typeof fetch;
+}): IBillingPort => {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  return {
+    requiresCustomer: true,
+    async getInvoicePdf(input) {
+      const res = await fetchImpl(
+        `https://api.stripe.com/v1/invoices/${encodeURIComponent(input.invoiceId)}`,
+        { headers: { authorization: `Bearer ${opts.secretKey}` } },
+      );
+      if (!res.ok) return null;
+      const json = (await res.json()) as {
+        customer?: string;
+        invoice_pdf?: string | null;
+        hosted_invoice_url?: string | null;
+      };
+      if (json.customer !== input.customerId) return null;
+      const url = json.invoice_pdf ?? json.hosted_invoice_url;
+      return url ? { url } : null;
+    },
+    async listInvoices(input) {
+      const res = await fetchImpl(
+        `https://api.stripe.com/v1/invoices?customer=${encodeURIComponent(input.customerId)}&limit=20`,
+        { headers: { authorization: `Bearer ${opts.secretKey}` } },
+      );
+      if (!res.ok) throw new AppError('INTERNAL', 'Invoices failed');
+      const json = (await res.json()) as {
+        data?: Array<{
+          id: string;
+          number?: string | null;
+          status?: string;
+          amount_due?: number;
+          currency?: string;
+          hosted_invoice_url?: string | null;
+          created?: number;
+        }>;
+      };
+      return (json.data ?? []).map(
+        (row): InvoiceDto => ({
+          id: row.id,
+          number: row.number ?? null,
+          status: row.status ?? 'open',
+          amountDue: row.amount_due ?? 0,
+          currency: row.currency ?? 'hkd',
+          hostedInvoiceUrl: row.hosted_invoice_url ?? null,
+          createdAt: new Date((row.created ?? 0) * 1000).toISOString(),
+        }),
+      );
+    },
+    async portal(input) {
+      const res = await fetchImpl('https://api.stripe.com/v1/billing_portal/sessions', {
+        method: 'POST',
+        headers: {
+          authorization: `Bearer ${opts.secretKey}`,
+          'content-type': 'application/x-www-form-urlencoded',
+        },
+        body: new URLSearchParams({
+          customer: input.customerId,
+          return_url: input.returnUrl,
+        }),
+      });
+      if (!res.ok) throw new AppError('INTERNAL', 'Portal failed');
+      const json = (await res.json()) as { url?: string };
+      if (!json.url) throw new AppError('INTERNAL', 'Portal failed');
+      return { url: json.url };
+    },
+    async checkout(input) {
+      if (input.planCode !== 'pro') throw new AppError('VALIDATION_FAILED', 'Unknown plan');
+      const params = new URLSearchParams({
+        mode: 'subscription',
+        success_url: input.successUrl,
+        cancel_url: input.cancelUrl,
+        client_reference_id: input.organizationId,
+        billing_address_collection: 'required',
+        'automatic_tax[enabled]': 'true',
+        'line_items[0][price]': opts.pricePro,
+        'line_items[0][quantity]': String(input.seatCount),
+        'metadata[organizationId]': input.organizationId,
+        'metadata[planCode]': input.planCode,
+        'metadata[seatCount]': String(input.seatCount),
+      });
+      if (input.customerId) {
+        params.set('customer', input.customerId);
+        params.set('customer_update[address]', 'auto');
+      }
+      const res = await fetchImpl('https://api.stripe.com/v1/checkout/sessions', {
+        method: 'POST',
+        headers: {
+          authorization: `Bearer ${opts.secretKey}`,
+          'content-type': 'application/x-www-form-urlencoded',
+        },
+        body: params,
+      });
+      if (!res.ok) throw new AppError('INTERNAL', 'Checkout failed');
+      const json = (await res.json()) as { url?: string };
+      if (!json.url) throw new AppError('INTERNAL', 'Checkout failed');
+      return { url: json.url, pending: true };
+    },
+  };
+};
+
+export const createBillingFromEnv = (
+  env: {
+    STRIPE_SECRET_KEY?: string | undefined;
+    STRIPE_PRICE_PRO?: string | undefined;
+  },
+  log: IBillingPort,
+): IBillingPort => {
+  if (env.STRIPE_SECRET_KEY && env.STRIPE_PRICE_PRO) {
+    return createStripeBilling({
+      secretKey: env.STRIPE_SECRET_KEY,
+      pricePro: env.STRIPE_PRICE_PRO,
+    });
+  }
+  return log;
+};