mppx 0.8.17 → 0.8.18

package/src/proxy/services/openai.ts

@@ -1,60 +0,0 @@
-import * as Service from '../Service.js'
-
-/**
- * Creates an OpenAI service definition.
- *
- * Injects `Authorization: Bearer` header for upstream authentication.
- * Per-endpoint `apiKey` overrides are supported via `options`.
- *
- * @example
- * ```ts
- * openai({
- *   apiKey: 'sk-...',
- *   routes: {
- *     'POST /v1/chat/completions': mppx.charge({ amount: '0.05' }),
- *     'GET /v1/models': true,
- *   },
- * })
- * ```
- */
-export function openai(config: openai.Config) {
-  return Service.from<openai.Config>('openai', {
-    baseUrl: config.baseUrl ?? 'https://api.openai.com',
-    categories: ['ai'],
-    description: 'Chat completions, embeddings, image generation, and audio transcription.',
-    docs: {
-      apiReference: 'https://platform.openai.com/docs/api-reference',
-      homepage: 'https://platform.openai.com/docs',
-      llms: 'https://context7.com/websites/platform_openai/llms.txt',
-    },
-    onUpstreamError: config.onUpstreamError,
-    rewriteRequest(request, ctx) {
-      const apiKey = ctx.apiKey ?? config.apiKey
-      request.headers.delete('OpenAI-Organization')
-      request.headers.delete('OpenAI-Project')
-      request.headers.set('Authorization', `Bearer ${apiKey}`)
-      return request
-    },
-    routes: config.routes,
-    title: 'OpenAI',
-  })
-}
-
-export declare namespace openai {
-  export type Config = Service.From<{
-    /** OpenAI API key. Used as `Authorization: Bearer` header. */
-    apiKey: string
-    /** Base URL override. Defaults to `'https://api.openai.com'`. */
-    baseUrl?: string | undefined
-    /** Route definitions for OpenAI endpoints. */
-    routes:
-      | 'POST /v1/chat/completions'
-      | 'POST /v1/completions'
-      | 'POST /v1/embeddings'
-      | 'POST /v1/images/generations'
-      | 'POST /v1/images/edits'
-      | 'POST /v1/images/variations'
-      | 'POST /v1/audio/transcriptions'
-      | 'POST /v1/audio/translations'
-  }>
-}

package/src/proxy/services/stripe.test.ts

@@ -1,175 +0,0 @@
-import { Receipt } from 'mppx'
-import { Mppx as Mppx_client, tempo as tempo_client } from 'mppx/client'
-import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
-import { afterEach, describe, expect, test } from 'vp/test'
-import * as Http from '~test/Http.js'
-import { accounts, asset, client } from '~test/tempo/viem.js'
-
-import * as ApiProxy from '../Proxy.js'
-import { stripe } from './stripe.js'
-
-const apiKey = 'sk_test_fake_stripe_key'
-const secretKey = 'test-secret-key-test-secret-key-32'
-
-const mppx_server = Mppx_server.create({
-  methods: [
-    tempo_server({
-      account: accounts[0],
-      currency: asset,
-      getClient: () => client,
-    }),
-  ],
-  secretKey,
-})
-
-const mppx_client = Mppx_client.create({
-  polyfill: false,
-  methods: [
-    tempo_client({
-      account: accounts[1],
-      getClient: () => client,
-    }),
-  ],
-})
-
-let proxyServer: Awaited<ReturnType<typeof Http.createServer>> | undefined
-let upstreamServer: Awaited<ReturnType<typeof Http.createServer>> | undefined
-
-afterEach(() => {
-  proxyServer?.close()
-  upstreamServer?.close()
-})
-
-describe('stripe', () => {
-  test('behavior: proxies POST /v1/charges with charge and injects Basic auth', async () => {
-    upstreamServer = await Http.createServer((req, res) => {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(
-        JSON.stringify({
-          headers: {
-            authorization: req.headers.authorization,
-          },
-        }),
-      )
-    })
-
-    const proxy = ApiProxy.create({
-      services: [
-        stripe({
-          apiKey,
-          baseUrl: upstreamServer.url,
-          routes: {
-            'POST /v1/charges': mppx_server.charge({ amount: '1', decimals: 6 }),
-          },
-        }),
-      ],
-    })
-    proxyServer = await Http.createServer(proxy.listener)
-
-    const res = await mppx_client.fetch(`${proxyServer.url}/stripe/v1/charges`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-      body: 'amount=100&currency=usd',
-    })
-    expect(res.status).toBe(200)
-
-    const body = (await res.json()) as { headers: { authorization: string } }
-    expect(body.headers.authorization).toBe(`Basic ${btoa(`${apiKey}:`)}`)
-
-    const receipt = Receipt.fromResponse(res)
-    expect(receipt.status).toBe('success')
-    expect(receipt.method).toBe('tempo')
-  })
-
-  test('security: strips caller-supplied Stripe-Account header before proxying', async () => {
-    upstreamServer = await Http.createServer((req, res) => {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(
-        JSON.stringify({
-          headers: {
-            authorization: req.headers.authorization,
-            stripeAccount: req.headers['stripe-account'],
-          },
-        }),
-      )
-    })
-
-    const proxy = ApiProxy.create({
-      services: [
-        stripe({
-          apiKey,
-          baseUrl: upstreamServer.url,
-          routes: {
-            'POST /v1/charges': true,
-          },
-        }),
-      ],
-    })
-    proxyServer = await Http.createServer(proxy.listener)
-
-    const res = await fetch(`${proxyServer.url}/stripe/v1/charges`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
-        'Stripe-Account': 'acct_123',
-      },
-      body: 'amount=100&currency=usd',
-    })
-    expect(res.status).toBe(200)
-
-    const body = (await res.json()) as {
-      headers: { authorization: string; stripeAccount?: string | string[] | undefined }
-    }
-    expect(body.headers.authorization).toBe(`Basic ${btoa(`${apiKey}:`)}`)
-    expect(body.headers.stripeAccount).toBeUndefined()
-  })
-
-  test('behavior: returns 402 without credential', async () => {
-    upstreamServer = await Http.createServer((_req, res) => {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end('{}')
-    })
-
-    const proxy = ApiProxy.create({
-      services: [
-        stripe({
-          apiKey,
-          baseUrl: upstreamServer.url,
-          routes: {
-            'POST /v1/charges': mppx_server.charge({ amount: '1', decimals: 6 }),
-          },
-        }),
-      ],
-    })
-    proxyServer = await Http.createServer(proxy.listener)
-
-    const res = await fetch(`${proxyServer.url}/stripe/v1/charges`, {
-      method: 'POST',
-    })
-    expect(res.status).toBe(402)
-    expect(res.headers.get('WWW-Authenticate')).toContain('Payment')
-  })
-
-  test('behavior: returns 404 for unmatched route', async () => {
-    upstreamServer = await Http.createServer((_req, res) => {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end('{}')
-    })
-
-    const proxy = ApiProxy.create({
-      services: [
-        stripe({
-          apiKey,
-          baseUrl: upstreamServer.url,
-          routes: {
-            'POST /v1/charges': mppx_server.charge({ amount: '1', decimals: 6 }),
-          },
-        }),
-      ],
-    })
-    proxyServer = await Http.createServer(proxy.listener)
-
-    const res = await fetch(`${proxyServer.url}/stripe/v1/unknown`)
-    expect(res.status).toBe(404)
-  })
-})

package/src/proxy/services/stripe.ts

@@ -1,59 +0,0 @@
-import * as Service from '../Service.js'
-
-/**
- * Creates a Stripe service definition.
- *
- * Injects `Authorization: Basic` header (API key as username) for upstream authentication.
- * Per-endpoint `apiKey` overrides are supported via `options`.
- *
- * @example
- * ```ts
- * stripe({
- *   apiKey: 'sk-...',
- *   routes: {
- *     'POST /v1/charges': mppx.charge({ amount: '1' }),
- *     'GET /v1/customers/:id': true,
- *   },
- * })
- * ```
- */
-export function stripe(config: stripe.Config) {
-  return Service.from<stripe.Config>('stripe', {
-    baseUrl: config.baseUrl ?? 'https://api.stripe.com',
-    categories: ['payments'],
-    description: 'Payment processing, customers, subscriptions, and invoices.',
-    docs: {
-      apiReference: 'https://docs.stripe.com/api',
-      homepage: 'https://docs.stripe.com',
-      llms: 'https://docs.stripe.com/llms.txt',
-    },
-    onUpstreamError: config.onUpstreamError,
-    rewriteRequest(request, ctx) {
-      const apiKey = ctx.apiKey ?? config.apiKey
-      request.headers.delete('Stripe-Account')
-      request.headers.set('Authorization', `Basic ${btoa(`${apiKey}:`)}`)
-      return request
-    },
-    routes: config.routes,
-    title: 'Stripe',
-  })
-}
-
-export declare namespace stripe {
-  export type Config = Service.From<{
-    /** Stripe API key. Used as Basic auth username. */
-    apiKey: string
-    /** Base URL override. Defaults to `'https://api.stripe.com'`. */
-    baseUrl?: string | undefined
-    routes:
-      | 'POST /v1/charges'
-      | 'POST /v1/customers'
-      | 'GET /v1/customers/:id'
-      | 'POST /v1/payment_intents'
-      | 'GET /v1/payment_intents/:id'
-      | 'POST /v1/subscriptions'
-      | 'GET /v1/subscriptions/:id'
-      | 'POST /v1/invoices'
-      | 'GET /v1/invoices/:id'
-  }>
-}

package/src/server/Methods.test-d.ts

@@ -1,88 +0,0 @@
-import { evm, stripe, tempo } from 'mppx/server'
-import { expectTypeOf, test } from 'vp/test'
-
-import type { StripeClient } from '../stripe/internal/types.js'
-
-test('all server method constructors expose typed canOffer hooks', () => {
-  tempo.charge({
-    canOffer({ input, request }) {
-      expectTypeOf(input).toEqualTypeOf<Request>()
-      expectTypeOf(request.amount).toEqualTypeOf<string>()
-      expectTypeOf(request.methodDetails?.chainId).toEqualTypeOf<number | undefined>()
-      return true
-    },
-  })
-
-  tempo.session({
-    canOffer({ input, request }) {
-      expectTypeOf(input).toEqualTypeOf<Request>()
-      expectTypeOf(request.amount).toEqualTypeOf<string>()
-      expectTypeOf(request.methodDetails?.chainId).toEqualTypeOf<number | undefined>()
-      return true
-    },
-  })
-
-  tempo.subscription({
-    canOffer({ input, request }) {
-      expectTypeOf(input).toEqualTypeOf<Request>()
-      expectTypeOf(request.amount).toEqualTypeOf<string>()
-      expectTypeOf(request.periodUnit).toEqualTypeOf<'dev_second' | 'day' | 'week'>()
-      return true
-    },
-    resolve: async () => null,
-  })
-
-  evm.charge({
-    canOffer({ input, request }) {
-      expectTypeOf(input).toEqualTypeOf<Request>()
-      expectTypeOf(request.amount).toEqualTypeOf<string>()
-      expectTypeOf(request.methodDetails.chainId).toEqualTypeOf<number>()
-      return true
-    },
-    currency: evm.assets.base.USDC,
-    recipient: '0x0000000000000000000000000000000000000001',
-    settle: async () => ({ reference: '0x01' }),
-  })
-
-  stripe.charge({
-    canOffer({ input, request }) {
-      expectTypeOf(input).toEqualTypeOf<Request>()
-      expectTypeOf(request.amount).toEqualTypeOf<string>()
-      expectTypeOf(request.methodDetails.networkId).toEqualTypeOf<string>()
-      return true
-    },
-    client: {} as StripeClient,
-    networkId: 'internal',
-    paymentMethodTypes: ['card'],
-  })
-})
-
-test('provider convenience constructors forward canOffer', () => {
-  evm({
-    canOffer({ request }) {
-      expectTypeOf(request.methodDetails.chainId).toEqualTypeOf<number>()
-      return true
-    },
-    currency: evm.assets.base.USDC,
-    recipient: '0x0000000000000000000000000000000000000001',
-    settle: async () => ({ reference: '0x01' }),
-  })
-
-  stripe.charge({
-    canOffer({ request }) {
-      expectTypeOf(request.methodDetails.networkId).toEqualTypeOf<string>()
-      return true
-    },
-    client: {} as StripeClient,
-    networkId: 'internal',
-    paymentMethodTypes: ['card'],
-  })
-
-  tempo({
-    canOffer({ input, request }) {
-      expectTypeOf(input).toEqualTypeOf<Request>()
-      expectTypeOf(request.amount).toEqualTypeOf<string>()
-      return true
-    },
-  })
-})

package/src/server/Methods.test.ts

@@ -1,69 +0,0 @@
-import { evm, stripe, tempo } from 'mppx/server'
-import { Methods as StripeMethods } from 'mppx/stripe'
-import { describe, expect, test, vi } from 'vp/test'
-import { accounts } from '~test/tempo/viem.js'
-
-const recipient = '0x0000000000000000000000000000000000000001'
-
-describe('composable method hooks', () => {
-  test('all server method constructors forward canOffer', () => {
-    const canOffer = vi.fn(() => true)
-    const methods = [
-      tempo.charge({ canOffer }),
-      tempo.session({ account: accounts[0], canOffer }),
-      tempo.subscription({
-        account: accounts[0],
-        canOffer,
-        resolve: async () => null,
-      }),
-      evm.charge({
-        canOffer,
-        currency: evm.assets.base.USDC,
-        recipient,
-        settle: async () => ({ reference: '0x01' }),
-      }),
-    ]
-
-    for (const method of methods) expect(method.canOffer).toBe(canOffer)
-  })
-
-  test('Tempo common constructor forwards canOffer to every intent', () => {
-    const canOffer = vi.fn(() => true)
-    const methods = tempo({ account: accounts[0], canOffer })
-
-    expect(tempo.common).toBe(tempo)
-    expect(methods).toHaveLength(2)
-    for (const method of methods) expect(method.canOffer).toBe(canOffer)
-  })
-
-  test('provider convenience constructors preserve canOffer', async () => {
-    const evmCanOffer = vi.fn(() => true)
-    const [evmCharge] = evm({
-      canOffer: evmCanOffer,
-      currency: evm.assets.base.USDC,
-      recipient,
-      settle: async () => ({ reference: '0x01' }),
-    })
-    expect(evmCharge.canOffer).toBe(evmCanOffer)
-
-    const stripeCanOffer = vi.fn(() => true)
-    const stripeCharge = stripe.charge({
-      canOffer: stripeCanOffer,
-      client: {} as never,
-      networkId: 'internal',
-      paymentMethodTypes: ['card'],
-    })
-    const request = StripeMethods.charge.schema.request.parse({
-      amount: '1',
-      currency: 'usd',
-      decimals: 2,
-      networkId: 'internal',
-      paymentMethodTypes: ['card'],
-    })
-
-    await expect(
-      stripeCharge.canOffer?.({ input: new Request('https://example.com'), request }),
-    ).resolves.toBe(true)
-    expect(stripeCanOffer).toHaveBeenCalledOnce()
-  })
-})

package/src/server/Methods.ts

@@ -1,3 +0,0 @@
-export { evm } from '../evm/server/index.js'
-export { stripe } from '../stripe/server/index.js'
-export { tempo } from '../tempo/server/index.js'

package/src/server/Mppx.authorize.test.ts

@@ -1,210 +0,0 @@
-import { Challenge, Credential, Method, z } from 'mppx'
-import { Mppx } from 'mppx/server'
-import { describe, expect, test } from 'vp/test'
-import * as Http from '~test/Http.js'
-
-const realm = 'api.example.com'
-const secretKey = 'test-secret-key-test-secret-key-32'
-
-function successReceipt(method = 'mock') {
-  return {
-    method,
-    reference: 'ref-1',
-    status: 'success',
-    timestamp: '2025-01-01T00:00:00.000Z',
-  } as const
-}
-
-describe('authorize hook', () => {
-  test('grants access without a Payment credential', async () => {
-    const method = Method.toServer(
-      Method.from({
-        name: 'mock',
-        intent: 'subscription',
-        schema: {
-          credential: { payload: z.object({ token: z.string() }) },
-          request: z.object({ amount: z.string() }),
-        },
-      }),
-      {
-        async authorize() {
-          return { receipt: successReceipt() }
-        },
-        async verify() {
-          return successReceipt()
-        },
-      },
-    )
-
-    const handler = Mppx.create({ methods: [method], realm, secretKey })
-    const result = await handler['mock/subscription']({ amount: '1' })(
-      new Request('https://example.com/resource'),
-    )
-
-    expect(result.status).toBe(200)
-    if (result.status !== 200) throw new Error('expected authorize success')
-
-    const response = result.withReceipt(new Response('OK'))
-    expect(response.headers.get('Payment-Receipt')).toBeTruthy()
-  })
-
-  test('toNodeListener forwards authorize management responses', async () => {
-    const method = Method.toServer(
-      Method.from({
-        name: 'mock',
-        intent: 'subscription',
-        schema: {
-          credential: { payload: z.object({ token: z.string() }) },
-          request: z.object({ amount: z.string() }),
-        },
-      }),
-      {
-        async authorize() {
-          return {
-            receipt: successReceipt(),
-            response: new Response('retry later', {
-              headers: { 'Retry-After': '1' },
-              status: 409,
-            }),
-          }
-        },
-        async verify() {
-          return successReceipt()
-        },
-      },
-    )
-
-    const handler = Mppx.create({ methods: [method], realm, secretKey })
-    const server = await Http.createServer(async (req, res) => {
-      const result = await Mppx.toNodeListener(handler['mock/subscription']({ amount: '1' }))(
-        req,
-        res,
-      )
-      if (result.status === 402) return
-      res.end('OK')
-    })
-
-    const response = await fetch(server.url)
-    expect(response.status).toBe(409)
-    expect(response.headers.get('Retry-After')).toBe('1')
-    expect(response.headers.get('Payment-Receipt')).toBeTruthy()
-    expect(await response.text()).toBe('retry later')
-
-    server.close()
-  })
-
-  test('compose evaluates authorize hooks sequentially on no-credential requests', async () => {
-    const calls: string[] = []
-    const createMethod = (
-      name: 'alpha' | 'beta',
-      authorizeResult?: ReturnType<typeof successReceipt>,
-    ) =>
-      Method.toServer(
-        Method.from({
-          name,
-          intent: 'charge',
-          schema: {
-            credential: { payload: z.object({ token: z.string() }) },
-            request: z.object({ amount: z.string() }),
-          },
-        }),
-        {
-          async authorize() {
-            calls.push(`${name}:start`)
-            await new Promise((resolve) => setTimeout(resolve, 0))
-            calls.push(`${name}:end`)
-            return authorizeResult ? { receipt: authorizeResult } : undefined
-          },
-          async verify() {
-            return successReceipt(name)
-          },
-        },
-      )
-
-    const alpha = createMethod('alpha')
-    const beta = createMethod('beta', successReceipt('beta'))
-    const handler = Mppx.create({ methods: [alpha, beta], realm, secretKey })
-
-    const result = await handler.compose(
-      [alpha, { amount: '1' }],
-      [beta, { amount: '1' }],
-    )(new Request('https://example.com/resource'))
-
-    expect(result.status).toBe(200)
-    expect(calls).toEqual(['alpha:start', 'alpha:end', 'beta:start', 'beta:end'])
-  })
-
-  test('stableBinding can reject mismatched subscription routes', async () => {
-    const method = Method.toServer(
-      Method.from({
-        name: 'mock',
-        intent: 'subscription',
-        schema: {
-          credential: { payload: z.object({ token: z.string() }) },
-          request: z.object({
-            amount: z.string(),
-            chainId: z.optional(z.number()),
-            currency: z.string(),
-            periodCount: z.string(),
-            periodUnit: z.enum(['day', 'week']),
-            recipient: z.string(),
-            subscriptionExpires: z.string(),
-          }),
-        },
-      }),
-      {
-        stableBinding(request) {
-          return {
-            amount: request.amount,
-            chainId: request.chainId,
-            currency: request.currency,
-            periodCount: request.periodCount,
-            periodUnit: request.periodUnit,
-            recipient: request.recipient,
-            subscriptionExpires: request.subscriptionExpires,
-          }
-        },
-        async verify() {
-          return successReceipt()
-        },
-      },
-    )
-
-    const handler = Mppx.create({ methods: [method], realm, secretKey })
-    const first = await handler['mock/subscription']({
-      amount: '1',
-      currency: 'usd',
-      periodCount: '30',
-      periodUnit: 'day',
-      recipient: 'alice',
-      subscriptionExpires: '2026-01-01T00:00:00Z',
-    })(new Request('https://example.com/cheap'))
-
-    expect(first.status).toBe(402)
-    if (first.status !== 402) throw new Error('expected challenge')
-
-    const credential = Credential.from({
-      challenge: Challenge.fromResponse(first.challenge),
-      payload: { token: 'ok' },
-    })
-
-    const second = await handler['mock/subscription']({
-      amount: '1',
-      currency: 'usd',
-      periodCount: '60',
-      periodUnit: 'day',
-      recipient: 'alice',
-      subscriptionExpires: '2026-01-01T00:00:00Z',
-    })(
-      new Request('https://example.com/expensive', {
-        headers: { Authorization: Credential.serialize(credential) },
-      }),
-    )
-
-    expect(second.status).toBe(402)
-    if (second.status !== 402) throw new Error('expected mismatch challenge')
-
-    const body = (await second.challenge.json()) as { detail: string }
-    expect(body.detail).toContain('periodCount')
-  })
-})