squash (#352)

Author: Yostra

apps/dashboard/e2e/pipeline-create.test.ts

@@ -29,12 +29,12 @@ test('full pipeline creation flow: source → discover → streams → destinati
 
   // Expand Payments and select a stream
   await page.getByText('Payments').click()
-  const chargesCheckbox = page.locator('label').filter({ hasText: 'charges' }).locator('input')
+  const chargesCheckbox = page.locator('label').filter({ hasText: 'charge' }).locator('input')
   await chargesCheckbox.check()
 
   // Expand Customers and select
   await page.getByText('Customers').click()
-  const customersCheckbox = page.locator('label').filter({ hasText: 'customers' }).locator('input')
+  const customersCheckbox = page.locator('label').filter({ hasText: 'customer' }).locator('input')
   await customersCheckbox.check()
 
   // Verify search works
@@ -57,8 +57,8 @@ test('full pipeline creation flow: source → discover → streams → destinati
   await expect(page.getByText('stripe').first()).toBeVisible()
   await expect(page.getByText('postgres').first()).toBeVisible()
   await expect(page.getByText('2 tables selected')).toBeVisible()
-  await expect(page.getByText('charges')).toBeVisible()
-  await expect(page.getByText('customers')).toBeVisible()
+  await expect(page.getByText('charge')).toBeVisible()
+  await expect(page.getByText('customer')).toBeVisible()
 
   // The "Start sync" button should be visible
   await expect(page.getByRole('button', { name: /start sync/i })).toBeVisible()

apps/dashboard/src/lib/stream-groups.test.ts

@@ -8,28 +8,28 @@ function stream(name: string): CatalogStream {
 describe('groupStreams', () => {
   it('groups payment-related streams together', () => {
     const streams = [
-      stream('payment_intents'),
-      stream('payment_methods'),
-      stream('charges'),
-      stream('refunds'),
+      stream('payment_intent'),
+      stream('payment_method'),
+      stream('charge'),
+      stream('refund'),
     ]
     const groups = groupStreams(streams)
     const payments = groups.find((g) => g.name === 'Payments')
     expect(payments).toBeDefined()
     expect(payments!.streams.map((s) => s.name)).toEqual(
-      expect.arrayContaining(['payment_intents', 'payment_methods', 'charges', 'refunds'])
+      expect.arrayContaining(['payment_intent', 'payment_method', 'charge', 'refund'])
     )
   })
 
   it('groups billing-related streams together', () => {
     const streams = [
-      stream('subscriptions'),
-      stream('subscription_schedules'),
-      stream('invoices'),
-      stream('prices'),
-      stream('plans'),
-      stream('coupons'),
-      stream('credit_notes'),
+      stream('subscription'),
+      stream('subscription_schedule'),
+      stream('invoice'),
+      stream('price'),
+      stream('plan'),
+      stream('coupon'),
+      stream('credit_note'),
     ]
     const groups = groupStreams(streams)
     const billing = groups.find((g) => g.name === 'Billing')
@@ -38,17 +38,17 @@ describe('groupStreams', () => {
   })
 
   it('sorts groups alphabetically', () => {
-    const streams = [stream('products'), stream('customers'), stream('charges')]
+    const streams = [stream('product'), stream('customer'), stream('charge')]
     const groups = groupStreams(streams)
     const names = groups.map((g) => g.name)
     expect(names).toEqual([...names].sort())
   })
 
   it('sorts streams within a group alphabetically', () => {
-    const streams = [stream('refunds'), stream('charges'), stream('disputes')]
+    const streams = [stream('refund'), stream('charge'), stream('dispute')]
     const groups = groupStreams(streams)
     const payments = groups.find((g) => g.name === 'Payments')!
-    expect(payments.streams.map((s) => s.name)).toEqual(['charges', 'disputes', 'refunds'])
+    expect(payments.streams.map((s) => s.name)).toEqual(['charge', 'dispute', 'refund'])
   })
 
   it('handles dotted names (v2 resources)', () => {
@@ -64,17 +64,14 @@ describe('groupStreams', () => {
 })
 
 describe('filterStreams', () => {
-  const streams = [stream('customers'), stream('charges'), stream('checkout_sessions')]
+  const streams = [stream('customer'), stream('charge'), stream('checkout_session')]
 
   it('filters by partial name match', () => {
-    expect(filterStreams(streams, 'ch').map((s) => s.name)).toEqual([
-      'charges',
-      'checkout_sessions',
-    ])
+    expect(filterStreams(streams, 'ch').map((s) => s.name)).toEqual(['charge', 'checkout_session'])
   })
 
   it('is case-insensitive', () => {
-    expect(filterStreams(streams, 'CUSTOMER').map((s) => s.name)).toEqual(['customers'])
+    expect(filterStreams(streams, 'CUSTOMER').map((s) => s.name)).toEqual(['customer'])
   })
 
   it('returns all streams for empty query', () => {

apps/dashboard/src/lib/stream-groups.ts

@@ -16,7 +16,7 @@ export interface StreamGroup {
  * Group streams by inferring categories from their names.
  *
  * Uses prefix heuristics — not a hardcoded mapping. Streams sharing a
- * common prefix word (e.g. "payment_intents", "payment_methods" → "Payment")
+ * common prefix word (e.g. "payment_intent", "payment_method" → "Payment")
  * are grouped together. Single-word names become their own group.
  *
  * The algorithm:
@@ -56,51 +56,35 @@ export function inferGroupName(streamName: string): string {
   // Handle snake_case names — use first word as group
   const firstWord = streamName.split('_')[0]
 
-  // Map known prefixes to Stripe product groups (both singular and plural forms)
+  // Map known prefixes to Stripe product groups (singular per resource naming spec).
   const REFINEMENTS: Record<string, string> = {
     subscription: 'Billing',
-    subscriptions: 'Billing',
     invoice: 'Billing',
-    invoices: 'Billing',
     credit: 'Billing',
     price: 'Billing',
-    prices: 'Billing',
     plan: 'Billing',
-    plans: 'Billing',
     coupon: 'Billing',
-    coupons: 'Billing',
     payment: 'Payments',
     charge: 'Payments',
-    charges: 'Payments',
     refund: 'Payments',
-    refunds: 'Payments',
     dispute: 'Payments',
-    disputes: 'Payments',
     setup: 'Payments',
     checkout: 'Checkout',
     customer: 'Customers',
-    customers: 'Customers',
     tax: 'Tax',
     product: 'Products',
-    products: 'Products',
     transfer: 'Transfers',
-    transfers: 'Transfers',
     payout: 'Payments',
-    payouts: 'Payments',
     balance: 'Transfers',
     application: 'Connect',
     account: 'Connect',
-    accounts: 'Connect',
     issuing: 'Issuing',
     treasury: 'Treasury',
     radar: 'Radar',
     early: 'Radar',
     file: 'Files',
-    files: 'Files',
     event: 'Events',
-    events: 'Events',
     webhook: 'Webhooks',
-    webhooks: 'Webhooks',
   }
 
   return REFINEMENTS[firstWord] ?? capitalize(firstWord)

apps/engine/src/__tests__/sync.test.ts

@@ -128,18 +128,18 @@ describe('sync lifecycle — run, checkpoint, resume', () => {
   it('run 1: writes records and persists state', async () => {
     const engine = await createEngine(makeResolver())
     const pipeline = {
-      source: { type: 'test', test: { streams: { customers: {} } } },
+      source: { type: 'test', test: { streams: { customer: {} } } },
       destination: {
         type: 'postgres',
         postgres: { url: connectionString, schema: SCHEMA },
       },
     }
 
     const input = [
-      record('customers', 'cus_1', { name: 'Alice' }),
-      record('customers', 'cus_2', { name: 'Bob' }),
-      record('customers', 'cus_3', { name: 'Charlie' }),
-      state('customers', { after: 'cus_3' }),
+      record('customer', 'cus_1', { name: 'Alice' }),
+      record('customer', 'cus_2', { name: 'Bob' }),
+      record('customer', 'cus_3', { name: 'Charlie' }),
+      state('customer', { after: 'cus_3' }),
     ]
 
     // Set up destination schema/tables, then run pipeline
@@ -158,13 +158,13 @@ describe('sync lifecycle — run, checkpoint, resume', () => {
 
     // Verify records were written
     const { rows: customers } = await pool.query(
-      `SELECT count(*)::int AS n FROM "${SCHEMA}".customers`
+      `SELECT count(*)::int AS n FROM "${SCHEMA}".customer`
     )
     expect(customers[0].n).toBe(3)
 
     // Verify state was persisted
     const { rows: stateRows } = await pool.query(
-      `SELECT data FROM "${SCHEMA}"."${STATE_TABLE}" WHERE stream = 'customers'`
+      `SELECT data FROM "${SCHEMA}"."${STATE_TABLE}" WHERE stream = 'customer'`
     )
     expect(stateRows).toHaveLength(1)
     expect(stateRows[0].data).toEqual({ after: 'cus_3' })
@@ -179,17 +179,17 @@ describe('sync lifecycle — run, checkpoint, resume', () => {
 
     const engine = await createEngine(makeResolver())
     const pipeline = {
-      source: { type: 'test', test: { streams: { customers: {} } } },
+      source: { type: 'test', test: { streams: { customer: {} } } },
       destination: {
         type: 'postgres',
         postgres: { url: connectionString, schema: SCHEMA },
       },
     }
 
     const input = [
-      record('customers', 'cus_4', { name: 'Diana' }),
-      record('customers', 'cus_5', { name: 'Eve' }),
-      state('customers', { after: 'cus_5' }),
+      record('customer', 'cus_4', { name: 'Diana' }),
+      record('customer', 'cus_5', { name: 'Eve' }),
+      state('customer', { after: 'cus_5' }),
     ]
 
     for await (const msg of engine.pipeline_sync(
@@ -209,13 +209,13 @@ describe('sync lifecycle — run, checkpoint, resume', () => {
 
     // Verify table now has 5 rows total (3 from run 1 + 2 from run 2)
     const { rows: customers } = await pool.query(
-      `SELECT count(*)::int AS n FROM "${SCHEMA}".customers`
+      `SELECT count(*)::int AS n FROM "${SCHEMA}".customer`
     )
     expect(customers[0].n).toBe(5)
 
     // Verify state was updated
     const { rows: stateRows } = await pool.query(
-      `SELECT data FROM "${SCHEMA}"."${STATE_TABLE}" WHERE stream = 'customers'`
+      `SELECT data FROM "${SCHEMA}"."${STATE_TABLE}" WHERE stream = 'customer'`
     )
     expect(stateRows).toHaveLength(1)
     expect(stateRows[0].data).toEqual({ after: 'cus_5' })