mppx 0.8.17 → 0.8.18

package/src/middlewares/internal/mppx.test.ts

@@ -1,177 +0,0 @@
-import { Challenge, Credential, Method, z } from 'mppx'
-import { Mppx } from 'mppx/server'
-import { describe, expect, test } from 'vp/test'
-
-import { wrap } from './mppx.js'
-
-const realm = 'api.example.com'
-const secretKey = 'test-secret-key-test-secret-key-32'
-
-const mockChargeA = Method.from({
-  name: 'alpha',
-  intent: 'charge',
-  schema: {
-    credential: {
-      payload: z.object({ token: z.string() }),
-    },
-    request: z.object({
-      amount: z.string(),
-      currency: z.string(),
-      decimals: z.number(),
-      recipient: z.string(),
-    }),
-  },
-})
-
-const mockChargeB = Method.from({
-  name: 'beta',
-  intent: 'charge',
-  schema: {
-    credential: {
-      payload: z.object({ token: z.string() }),
-    },
-    request: z.object({
-      amount: z.string(),
-      currency: z.string(),
-      decimals: z.number(),
-      recipient: z.string(),
-    }),
-  },
-})
-
-function mockReceipt(name: string) {
-  return {
-    method: name,
-    reference: `tx-${name}`,
-    status: 'success' as const,
-    timestamp: new Date().toISOString(),
-  }
-}
-
-const alphaMethod = Method.toServer(mockChargeA, {
-  async verify() {
-    return mockReceipt('alpha')
-  },
-})
-
-const betaMethod = Method.toServer(mockChargeB, {
-  async verify() {
-    return mockReceipt('beta')
-  },
-})
-
-const alphaMethodWithExtension = Method.toServer<
-  typeof mockChargeA,
-  {},
-  undefined,
-  { renew: () => string }
->(mockChargeA, {
-  extensions: {
-    renew: () => 'renewed',
-  },
-  async verify() {
-    return mockReceipt('alpha')
-  },
-})
-
-const challengeOpts = {
-  amount: '1000',
-  currency: '0x0000000000000000000000000000000000000001',
-  decimals: 6,
-  expires: new Date(Date.now() + 60_000).toISOString(),
-  recipient: '0x0000000000000000000000000000000000000002',
-}
-
-describe('wrap: nested handlers', () => {
-  test('wrapped.alpha.charge produces a wrapped handler', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey }) as any
-
-    const wrapped = wrap(mppx, (methodFn, options) => {
-      return { type: 'wrapped' as const, handler: methodFn(options) }
-    })
-
-    const result = wrapped.alpha.charge(challengeOpts)
-    expect(result.type).toBe('wrapped')
-    expect(typeof result.handler).toBe('function')
-  })
-
-  test('wrapped.beta.charge produces a wrapped handler', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey }) as any
-
-    const wrapped = wrap(mppx, (methodFn, options) => {
-      return { type: 'wrapped' as const, handler: methodFn(options) }
-    })
-
-    const result = wrapped.beta.charge(challengeOpts)
-    expect(result.type).toBe('wrapped')
-  })
-
-  test('nested wrapped handler works end-to-end (402 then 200)', async () => {
-    const mppx = Mppx.create({ methods: [alphaMethod], realm, secretKey }) as any
-
-    const wrapped = wrap(mppx, (methodFn, options) => methodFn(options))
-
-    const handle = wrapped.alpha.charge(challengeOpts)
-
-    const firstResult = await handle(new Request('https://example.com/resource'))
-    expect(firstResult.status).toBe(402)
-    if (firstResult.status !== 402) throw new Error()
-
-    const challenge = Challenge.fromResponse(firstResult.challenge)
-    const credential = Credential.from({ challenge, payload: { token: 'valid' } })
-
-    const result = await handle(
-      new Request('https://example.com/resource', {
-        headers: { Authorization: Credential.serialize(credential) },
-      }),
-    )
-    expect(result.status).toBe(200)
-  })
-
-  test('slash key and nested key produce equivalent wrapped handlers', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod], realm, secretKey }) as any
-
-    const wrapped = wrap(mppx, (methodFn, options) => {
-      return { methodFn, options }
-    })
-
-    const nestedResult = wrapped.alpha.charge(challengeOpts) as {
-      methodFn: unknown
-      options: unknown
-    }
-    const slashResult = wrapped['alpha/charge'](challengeOpts) as {
-      methodFn: unknown
-      options: unknown
-    }
-
-    expect(nestedResult.methodFn).toBe(slashResult.methodFn)
-    expect(nestedResult.options).toEqual(slashResult.options)
-  })
-
-  test('compose is omitted from wrapped object', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod], realm, secretKey }) as any
-
-    const wrapped = wrap(mppx, (_methodFn, _options) => 'wrapped')
-
-    expect(wrapped.compose).toBeUndefined()
-  })
-
-  test('realm and transport are passed through', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod], realm, secretKey }) as any
-
-    const wrapped = wrap(mppx, (_methodFn, _options) => 'wrapped')
-
-    expect(wrapped.realm).toBe(realm)
-    expect(wrapped.transport).toBe(mppx.transport)
-  })
-
-  test('method extensions are copied to wrapped handlers', () => {
-    const mppx = Mppx.create({ methods: [alphaMethodWithExtension], realm, secretKey }) as any
-
-    const wrapped = wrap(mppx, (_methodFn, _options) => 'wrapped') as any
-
-    expect(wrapped.charge.renew()).toBe('renewed')
-    expect(wrapped.alpha.charge.renew()).toBe('renewed')
-    expect(wrapped['alpha/charge'].renew()).toBe('renewed')
-  })
-})

package/src/middlewares/internal/mppx.ts

@@ -1,67 +0,0 @@
-import type { DiscoveryHandler } from '../../discovery/OpenApi.js'
-import type * as Method from '../../Method.js'
-import { reservedMppxKeys } from '../../server/Mppx.js'
-import type * as Mppx from '../../server/Mppx.js'
-
-export type AnyMethodFn = Mppx.AnyMethodFn
-export type AnyServer = Method.AnyServer
-
-type DiscoveryMeta = Pick<DiscoveryHandler, '_internal'>
-
-/** Recursively wraps nested handler objects one level deep. */
-type WrapNested<obj, handler> = {
-  [key in keyof obj]: obj[key] extends (options: infer options) => any
-    ? WrappedMethod<obj[key], options, handler>
-    : obj[key]
-}
-
-type WrappedMethod<method, options, handler> = ((o: options) => handler & DiscoveryMeta) &
-  Omit<method, keyof Function>
-
-export type Wrap<mppx, handler> = {
-  // `compose` is omitted — it returns a raw HTTP handler, not a
-  // middleware-shaped result. Use `Mppx.compose()` static instead.
-  // Reserved Mppx keys are copied through unchanged, not wrapped as handlers.
-  [key in keyof mppx as key extends 'compose' ? never : key]: key extends Mppx.ReservedKey
-    ? mppx[key]
-    : mppx[key] extends (options: infer options) => any
-      ? WrappedMethod<mppx[key], options, handler>
-      : mppx[key] extends Record<string, (options: any) => any>
-        ? WrapNested<mppx[key], handler>
-        : mppx[key]
-}
-
-/**
- * Wraps a payment handler so each method returns a framework-specific
- * handler instead of the raw method response.
- *
- * @param mppx - The payment handler created by `Mppx.create`.
- * @param wrapper - A function that adapts a method function into a framework handler.
- */
-export function wrap<mppx extends Mppx.Mppx<any, any>, handler>(
-  mppx: mppx,
-  wrapper: (method: AnyMethodFn, options: any) => handler,
-): Wrap<mppx, handler> {
-  const { compose: _, ...rest } = mppx as any
-  const result: Record<string, unknown> = { ...rest }
-  for (const mi of mppx.methods as readonly Method.AnyServer[]) {
-    const key = `${mi.name}/${mi.intent}`
-    const methodFn = (mppx as any)[key]
-    const wrapWithMeta = (options: any) => {
-      const configured = methodFn(options)
-      const handler = wrapper(methodFn, options) as any
-      if (configured._internal) handler._internal = configured._internal
-      return handler
-    }
-    Object.assign(wrapWithMeta, methodFn)
-    result[key] = wrapWithMeta
-    // Also set shorthand intent key if Mppx registered it (no collision)
-    if (!reservedMppxKeys.has(mi.intent) && (mppx as any)[mi.intent])
-      result[mi.intent] = wrapWithMeta
-    // Build nested handlers: wrapped.tempo.charge(...)
-    if (!result[mi.name] || typeof result[mi.name] !== 'object')
-      result[mi.name] = {} as Record<string, unknown>
-    ;(result[mi.name] as Record<string, unknown>)[mi.intent] = wrapWithMeta
-  }
-  return result as never
-}

package/src/middlewares/nextjs.test.ts

@@ -1,359 +0,0 @@
-import * as http from 'node:http'
-
-import { Challenge, Credential, Receipt } from 'mppx'
-import { Mppx as Mppx_client, session as sessionIntent, tempo as tempo_client } from 'mppx/client'
-import { Mppx, discovery, payment } from 'mppx/nextjs'
-import { tempo as tempo_server } from 'mppx/server'
-import { Addresses } from 'viem/tempo'
-import { beforeAll, describe, expect, test } from 'vp/test'
-import * as TestHttp from '~test/Http.js'
-import { accounts, asset, chain, client, fundAccount } from '~test/tempo/viem.js'
-
-function createServer(handler: (request: Request) => Promise<Response> | Response) {
-  return new Promise<TestHttp.TestServer>((resolve) => {
-    const server = http.createServer(async (req, res) => {
-      const url = `http://localhost${req.url}`
-      const headers = new Headers()
-      for (let i = 0; i < req.rawHeaders.length; i += 2)
-        headers.append(req.rawHeaders[i]!, req.rawHeaders[i + 1]!)
-      const request = new Request(url, { method: req.method!, headers })
-      const response = await handler(request)
-      res.writeHead(response.status, Object.fromEntries(response.headers))
-      const body = await response.text()
-      if (body) res.write(body)
-      res.end()
-    })
-    server.listen(0, () => {
-      const { port } = server.address() as { port: number }
-      resolve(TestHttp.wrapServer(server, { port, url: `http://localhost:${port}` }))
-    })
-  })
-}
-
-const secretKey = 'test-secret-key-test-secret-key-32'
-
-describe('payment', () => {
-  test('short-circuits management responses', async () => {
-    let handlerRan = false
-    const intent = () => async () => ({
-      status: 200 as const,
-      withReceipt: () =>
-        new Response(null, {
-          headers: { 'Payment-Receipt': 'management-receipt' },
-          status: 204,
-        }),
-    })
-    const handler = payment(intent as any, {} as any, () => {
-      handlerRan = true
-      return Response.json({ data: 'content' })
-    })
-
-    const server = await createServer(handler)
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(204)
-    expect(response.headers.get('Payment-Receipt')).toBe('management-receipt')
-    expect(await response.text()).toBe('')
-    expect(handlerRan).toBe(false)
-
-    server.close()
-  })
-
-  test('copies transport-specific success headers', async () => {
-    const intent = () => async () => ({
-      status: 200 as const,
-      withReceipt: (response?: Response) =>
-        new Response(response?.body ?? null, {
-          headers: {
-            ...(response ? Object.fromEntries(response.headers) : {}),
-            'PAYMENT-RESPONSE': 'x402-response',
-          },
-          status: response?.status ?? 200,
-        }),
-    })
-    const handler = payment(intent as any, {} as any, () => Response.json({ data: 'content' }))
-
-    const server = await createServer(handler)
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(response.headers.get('PAYMENT-RESPONSE')).toBe('x402-response')
-
-    server.close()
-  })
-})
-
-function createChargeHarness(feePayer: boolean) {
-  const mppx = Mppx.create({
-    methods: [
-      tempo_server.charge({
-        getClient: () => client,
-        currency: asset,
-        account: accounts[0],
-        ...(feePayer ? { feePayer: true } : {}),
-      }),
-    ],
-    secretKey,
-  })
-
-  const { fetch } = Mppx_client.create({
-    polyfill: false,
-    methods: [
-      tempo_client.charge({
-        account: accounts[1],
-        getClient: () => client,
-      }),
-    ],
-  })
-
-  return { fetch, mppx }
-}
-
-describe('charge', () => {
-  test('returns 402 when no credential', async () => {
-    const { mppx } = createChargeHarness(false)
-
-    const handler = mppx.charge({ amount: '1' })(() =>
-      Response.json({ fortune: 'You will be rich' }),
-    )
-
-    const server = await createServer(handler)
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(402)
-    expect(response.headers.get('WWW-Authenticate')).toContain('Payment')
-
-    server.close()
-  })
-
-  test('returns 200 with receipt on valid payment', async () => {
-    const { fetch, mppx } = createChargeHarness(false)
-
-    const handler = mppx.charge({ amount: '1' })(() =>
-      Response.json({ fortune: 'You will be rich' }),
-    )
-
-    const server = await createServer(handler)
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-
-    const body = await response.json()
-    expect(body).toEqual({ fortune: 'You will be rich' })
-
-    const receipt = Receipt.fromResponse(response)
-    expect(receipt.status).toBe('success')
-    expect(receipt.method).toBe('tempo')
-
-    server.close()
-  })
-
-  test('fee payer: returns 200 with receipt on valid payment', async () => {
-    const { fetch, mppx } = createChargeHarness(true)
-
-    const handler = mppx.charge({ amount: '1' })(() =>
-      Response.json({ fortune: 'You will be rich' }),
-    )
-
-    const server = await createServer(handler)
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(Receipt.fromResponse(response).status).toBe('success')
-
-    server.close()
-  })
-
-  test('zero-amount charge creates a proof credential and receipt', async () => {
-    const { fetch, mppx } = createChargeHarness(false)
-
-    const handler = mppx.charge({ amount: '0' })((request) =>
-      Response.json({ payer: request.headers.get('Authorization') }),
-    )
-
-    const server = await createServer(handler)
-
-    const challengeResponse = await globalThis.fetch(server.url)
-    expect(challengeResponse.status).toBe(402)
-
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-
-    const body = (await response.json()) as { payer: string }
-    const credential = Credential.deserialize<{ signature: string; type: 'proof' }>(body.payer)
-    expect(credential.challenge.request.amount).toBe('0')
-    expect(credential.payload.type).toBe('proof')
-    expect(credential.source).toBe(`did:pkh:eip155:${chain.id}:${accounts[1].address}`)
-
-    const receipt = Receipt.fromResponse(response)
-    expect(receipt.reference).toBe(credential.challenge.id)
-
-    server.close()
-  })
-
-  test('zero-amount charge with testnet currency omission creates a proof credential', async () => {
-    const isTestnet = true
-    const mainnetCurrency = '0x20C000000000000000000000b9537d11c60E8b50' as const
-
-    const mppx = Mppx.create({
-      methods: [
-        tempo_server.charge({
-          account: accounts[0],
-          getClient: () => client,
-          ...(isTestnet ? {} : { currency: mainnetCurrency }),
-          recipient: accounts[0].address,
-          testnet: isTestnet,
-        }),
-      ],
-      secretKey,
-    })
-
-    const { fetch } = Mppx_client.create({
-      polyfill: false,
-      methods: [
-        tempo_client.charge({
-          account: accounts[1],
-          getClient: () => client,
-        }),
-      ],
-    })
-
-    const handler = mppx.charge({ amount: '0', chainId: chain.id })((request) =>
-      Response.json({ payer: request.headers.get('Authorization') }),
-    )
-
-    const server = await createServer(handler)
-
-    const challengeResponse = await globalThis.fetch(server.url)
-    expect(challengeResponse.status).toBe(402)
-
-    const challenge = Challenge.fromResponse(challengeResponse, {
-      methods: [tempo_client.charge()],
-    })
-    expect(challenge.request.currency).toBe('0x20c0000000000000000000000000000000000000')
-
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-
-    const body = (await response.json()) as { payer: string }
-    const credential = Credential.deserialize<{ signature: string; type: 'proof' }>(body.payer)
-    expect(credential.challenge.request.amount).toBe('0')
-    expect(credential.challenge.request.currency).toBe('0x20c0000000000000000000000000000000000000')
-    expect(credential.payload.type).toBe('proof')
-    expect(credential.source).toBe(`did:pkh:eip155:${chain.id}:${accounts[1].address}`)
-
-    const receipt = Receipt.fromResponse(response)
-    expect(receipt.reference).toBe(credential.challenge.id)
-
-    server.close()
-  })
-
-  test('serves /openapi.json from a handler-derived route config', async () => {
-    const { mppx } = createChargeHarness(false)
-
-    const pay = mppx.charge({ amount: '1' })
-    const server = await createServer(
-      discovery(mppx, {
-        info: { title: 'Next API', version: '3.0.0' },
-        routes: [{ handler: pay, method: 'get', path: '/' }],
-      }),
-    )
-
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(response.headers.get('cache-control')).toBe('public, max-age=300')
-
-    const body = (await response.json()) as Record<string, any>
-    expect(body.info).toEqual({ title: 'Next API', version: '3.0.0' })
-    expect(body.paths['/'].get['x-payment-info'].offers[0]).toMatchObject({
-      amount: '1000000',
-      currency: asset,
-      intent: 'charge',
-      method: 'tempo',
-    })
-
-    server.close()
-  })
-})
-
-describe('session', () => {
-  function createSessionHarness(feePayer: boolean) {
-    const mppx = Mppx.create({
-      methods: [
-        tempo_server.session({
-          getClient: () => client,
-          account: accounts[0],
-          currency: asset,
-          ...(feePayer ? { feePayer: accounts[1] } : {}),
-        } as any),
-      ],
-      secretKey,
-    })
-
-    const { fetch } = Mppx_client.create({
-      polyfill: false,
-      methods: [
-        sessionIntent({
-          account: accounts[2],
-          maxDeposit: '10',
-          getClient: () => client,
-        }),
-      ],
-    })
-
-    return { fetch, mppx }
-  }
-
-  beforeAll(async () => {
-    await fundAccount({ address: accounts[1].address, token: Addresses.pathUsd })
-    await fundAccount({ address: accounts[1].address, token: asset })
-    await fundAccount({ address: accounts[2].address, token: Addresses.pathUsd })
-    await fundAccount({ address: accounts[2].address, token: asset })
-  })
-
-  test('returns 402 when no credential', async () => {
-    const { mppx } = createSessionHarness(false)
-
-    const handler = mppx.session({ amount: '1', currency: asset, unitType: 'token' })(() =>
-      Response.json({ data: 'streamed' }),
-    )
-
-    const server = await createServer(handler)
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(402)
-    expect(response.headers.get('WWW-Authenticate')).toContain('Payment')
-
-    server.close()
-  })
-
-  test('returns 200 with receipt on valid payment', async () => {
-    const { fetch, mppx } = createSessionHarness(false)
-
-    const handler = mppx.session({ amount: '1', currency: asset, unitType: 'token' })(() =>
-      Response.json({ data: 'streamed' }),
-    )
-
-    const server = await createServer(handler)
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-
-    const body = await response.json()
-    expect(body).toEqual({ data: 'streamed' })
-
-    const receipt = Receipt.fromResponse(response)
-    expect(receipt.status).toBe('success')
-    expect(receipt.method).toBe('tempo')
-
-    server.close()
-  })
-
-  test('fee payer: returns 200 with receipt on valid payment', async () => {
-    const { fetch, mppx } = createSessionHarness(true)
-
-    const handler = mppx.session({ amount: '1', currency: asset, unitType: 'token' })(() =>
-      Response.json({ data: 'streamed' }),
-    )
-
-    const server = await createServer(handler)
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(Receipt.fromResponse(response).status).toBe('success')
-
-    server.close()
-  })
-})

package/src/middlewares/nextjs.ts

@@ -1,107 +0,0 @@
-import { generate, type GenerateConfig, type RouteConfig } from '../discovery/OpenApi.js'
-import * as Mppx_core from '../server/Mppx.js'
-import * as Mppx_internal from './internal/mppx.js'
-
-export * from '../server/Methods.js'
-
-type RouteHandler = (request: Request) => Promise<Response> | Response
-
-type NextjsHandler = (handler: RouteHandler) => RouteHandler
-
-export namespace Mppx {
-  /**
-   * Creates a Next.js-aware payment handler where each intent
-   * returns a wrapper that accepts a route handler.
-   *
-   * @example
-   * ```ts
-   * // app/api/premium/route.ts
-   * import { Mppx, tempo } from 'mppx/nextjs'
-   *
-   * const mppx = Mppx.create({ methods: [tempo()] })
-   *
-   * export const GET = mppx.charge({ amount: '1' })(() =>
-   *   Response.json({ data: 'paid content' }),
-   * )
-   * ```
-   */
-  export function create<const methods extends Mppx_core.Methods>(
-    config: Mppx_core.create.Config<methods>,
-  ): Mppx_internal.Wrap<Mppx_core.Mppx<methods>, NextjsHandler> {
-    return Mppx_internal.wrap(Mppx_core.create(config), (intent, options) => {
-      return (handler: RouteHandler) => payment(intent, options, handler)
-    })
-  }
-}
-
-/**
- * Next.js route handler wrapper that gates a route behind a payment intent.
- *
- * Returns a 402 challenge if no valid credential is provided,
- * otherwise attaches a `Payment-Receipt` header to the response.
- *
- * @example
- * ```ts
- * // app/api/premium/route.ts
- * import { Mppx } from 'mppx/server'
- * import { payment } from 'mppx/nextjs'
- *
- * const mppx = Mppx.create({ methods: [tempo()] })
- *
- * export const GET = payment(mppx.charge, { amount: '1' }, () =>
- *   Response.json({ data: 'paid content' }),
- * )
- * ```
- */
-export function payment<const intent extends Mppx_internal.AnyMethodFn>(
-  intent: intent,
-  options: intent extends (options: infer options) => any ? options : never,
-  handler: RouteHandler,
-): RouteHandler {
-  return async (request) => {
-    const result = await intent(options)(request)
-    if (result.status === 402) return result.challenge
-    const managementResponse = getManagementResponse(result)
-    if (managementResponse) return managementResponse
-    const response = await handler(request)
-    return result.withReceipt(response)
-  }
-}
-
-function getManagementResponse(result: { withReceipt: (response?: Response) => Response }) {
-  try {
-    return result.withReceipt()
-  } catch (error) {
-    if (Mppx_core.isMissingReceiptResponseError(error)) {
-      return null
-    }
-    throw error
-  }
-}
-
-export type DiscoveryConfig = Omit<GenerateConfig, 'routes'> & {
-  routes?: RouteConfig[]
-}
-
-const discoveryHeaders = { 'Cache-Control': 'public, max-age=300' }
-
-/**
- * Creates a route handler that serves an OpenAPI discovery document.
- */
-export function discovery(
-  mppx: { methods: readonly Mppx_internal.AnyServer[]; realm: string },
-  config: DiscoveryConfig = {},
-): RouteHandler {
-  const cached = JSON.stringify(
-    generate(mppx, {
-      ...(config.info ? { info: config.info } : {}),
-      routes: config.routes ?? [],
-      ...(config.serviceInfo ? { serviceInfo: config.serviceInfo } : {}),
-    }),
-  )
-
-  return () =>
-    new Response(cached, {
-      headers: { ...discoveryHeaders, 'Content-Type': 'application/json' },
-    })
-}