mppx 0.8.15 → 0.8.18

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')
-  })
-})

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

@@ -1,360 +0,0 @@
-import { Method, z } from 'mppx'
-import { Mppx, tempo } from 'mppx/server'
-import { assertType, describe, expectTypeOf, test } from 'vp/test'
-
-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(),
-    }),
-  },
-})
-
-const mockSession = Method.from({
-  name: 'tempo',
-  intent: 'session',
-  schema: {
-    credential: {
-      payload: z.object({ token: z.string() }),
-    },
-    request: z.object({
-      amount: z.string(),
-      currency: z.string(),
-      methodDetails: z.object({ sessionProtocol: z.string() }),
-      unitType: z.string(),
-    }),
-  },
-})
-
-const alphaMethod = Method.toServer(mockChargeA, {
-  async verify() {
-    return {
-      method: 'alpha',
-      reference: 'tx',
-      status: 'success' as const,
-      timestamp: new Date().toISOString(),
-    }
-  },
-})
-
-const betaMethod = Method.toServer(mockChargeB, {
-  async verify() {
-    return {
-      method: 'beta',
-      reference: 'tx',
-      status: 'success' as const,
-      timestamp: new Date().toISOString(),
-    }
-  },
-})
-
-const tip1034SessionMethod = Method.toServer(mockSession, {
-  async verify() {
-    return {
-      method: 'tempo',
-      reference: 'tx',
-      status: 'success' as const,
-      timestamp: new Date().toISOString(),
-    }
-  },
-})
-
-const legacySessionMethod = Method.toServer(mockSession, {
-  alias: 'sessionLegacy',
-  async verify() {
-    return {
-      method: 'tempo',
-      reference: 'tx',
-      status: 'success' as const,
-      timestamp: new Date().toISOString(),
-    }
-  },
-})
-
-const secretKey = 'test-secret-key-test-secret-key-32'
-const realm = 'api.example.com'
-
-describe('Mppx type tests', () => {
-  test('compose exists on the instance and returns a handler', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
-
-    expectTypeOf(mppx.compose).toBeFunction()
-  })
-
-  test('compose accepts method reference tuples', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
-
-    const opts = {
-      amount: '100',
-      currency: '0x01',
-      decimals: 6,
-      recipient: '0x02',
-    }
-
-    // Should compile — method reference entries
-    const handler = mppx.compose([alphaMethod, opts], [betaMethod, opts])
-    expectTypeOf(handler).toBeFunction()
-  })
-
-  test('compose accepts string key tuples', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
-
-    const opts = {
-      amount: '100',
-      currency: '0x01',
-      decimals: 6,
-      recipient: '0x02',
-    }
-
-    // Should compile — string key entries
-    const handler = mppx.compose(['alpha/charge', opts], ['beta/charge', opts])
-    expectTypeOf(handler).toBeFunction()
-  })
-
-  test('nested handlers are accessible', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
-
-    expectTypeOf(mppx.alpha).toBeObject()
-    expectTypeOf(mppx.alpha.charge).toBeFunction()
-    expectTypeOf(mppx.beta).toBeObject()
-    expectTypeOf(mppx.beta.charge).toBeFunction()
-  })
-
-  test('aliased duplicate handlers are accessible by nested and slash keys', () => {
-    const mppx = Mppx.create({
-      methods: [tip1034SessionMethod, legacySessionMethod],
-      realm,
-      secretKey,
-    })
-
-    expectTypeOf(mppx.tempo.session).toBeFunction()
-    expectTypeOf(mppx.tempo.sessionLegacy).toBeFunction()
-    expectTypeOf(mppx['tempo/session']).toBeFunction()
-    expectTypeOf(mppx['tempo/sessionLegacy']).toBeFunction()
-    expectTypeOf(mppx.challenge.tempo.session).toBeFunction()
-    expectTypeOf(mppx.challenge.tempo.sessionLegacy).toBeFunction()
-  })
-
-  test('slash key handlers are accessible', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
-
-    expectTypeOf(mppx['alpha/charge']).toBeFunction()
-    expectTypeOf(mppx['beta/charge']).toBeFunction()
-  })
-
-  test('compose return type is a request handler returning the response union', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod], realm, secretKey })
-
-    const opts = {
-      amount: '100',
-      currency: '0x01',
-      decimals: 6,
-      recipient: '0x02',
-    }
-
-    const _handler = mppx.compose([alphaMethod, opts])
-    type HandlerReturn = ReturnType<typeof _handler>
-
-    assertType<Promise<{ status: 402; challenge: Response } | { status: 200; withReceipt: any }>>(
-      {} as Awaited<HandlerReturn> as any,
-    )
-  })
-
-  test('static Mppx.compose accepts configured handlers', () => {
-    expectTypeOf(Mppx.compose).toBeFunction()
-  })
-
-  test('challenge namespace has nested accessors matching methods', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
-
-    expectTypeOf(mppx.challenge).toBeObject()
-    expectTypeOf(mppx.challenge.alpha).toBeObject()
-    expectTypeOf(mppx.challenge.alpha.charge).toBeFunction()
-    expectTypeOf(mppx.challenge.beta).toBeObject()
-    expectTypeOf(mppx.challenge.beta.charge).toBeFunction()
-  })
-
-  test('challenge functions return Promise<Challenge>', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod], realm, secretKey })
-
-    const challenge = mppx.challenge.alpha.charge({
-      amount: '100',
-      currency: '0x01',
-      decimals: 6,
-      expires: new Date('2026-01-01T00:00:00Z'),
-      recipient: '0x02',
-    })
-
-    expectTypeOf(challenge).toMatchTypeOf<Promise<unknown>>()
-
-    type AwaitedChallenge = Awaited<typeof challenge>
-    expectTypeOf<AwaitedChallenge>().toHaveProperty('id')
-    expectTypeOf<AwaitedChallenge>().toHaveProperty('realm')
-    expectTypeOf<AwaitedChallenge>().toHaveProperty('method')
-    expectTypeOf<AwaitedChallenge>().toHaveProperty('intent')
-    expectTypeOf<AwaitedChallenge>().toHaveProperty('request')
-  })
-
-  test('verifyCredential exists and returns Promise<Receipt>', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod], realm, secretKey })
-
-    expectTypeOf(mppx.verifyCredential).toBeFunction()
-    expectTypeOf(mppx.broadcastCredential).toBeFunction()
-    expectTypeOf(mppx.validateCredential).toBeFunction()
-  })
-
-  test('server events receive typed method context', () => {
-    const mppx = Mppx.create({
-      methods: [alphaMethod],
-      realm,
-      secretKey,
-    })
-
-    mppx.on('payment.success', (context) => {
-      expectTypeOf(context.challenge.method).toEqualTypeOf<'alpha'>()
-      expectTypeOf(context.credential?.payload.token).toEqualTypeOf<string | undefined>()
-    })
-    mppx.on('challenge.created', (context) => {
-      expectTypeOf(context.method.name).toEqualTypeOf<'alpha'>()
-      expectTypeOf(context.error).toMatchTypeOf<Error | undefined>()
-    })
-    mppx.on('payment.failed', (context) => {
-      expectTypeOf(context.error).toMatchTypeOf<Error>()
-      expectTypeOf(context.credential).toMatchTypeOf<unknown>()
-    })
-    mppx.on('*', (event) => {
-      expectTypeOf(event.name).toMatchTypeOf<
-        'challenge.created' | 'payment.failed' | 'payment.success'
-      >()
-      if (event.name === 'payment.failed') expectTypeOf(event.payload.error).toMatchTypeOf<Error>()
-      if (event.name === 'challenge.created')
-        expectTypeOf(event.payload.error).toMatchTypeOf<Error | undefined>()
-      if (event.name === 'payment.success')
-        expectTypeOf(event.payload.receipt.status).toEqualTypeOf<'success'>()
-    })
-    mppx.onChallengeCreated((context) => {
-      expectTypeOf(context.input).toEqualTypeOf<Request | undefined>()
-      expectTypeOf(context.method.name).toEqualTypeOf<'alpha'>()
-      expectTypeOf(context.request.amount).toEqualTypeOf<string>()
-      expectTypeOf(context.error).toMatchTypeOf<Error | undefined>()
-    })
-    mppx.onPaymentSuccess((context) => {
-      expectTypeOf(context.challenge.method).toEqualTypeOf<'alpha'>()
-      expectTypeOf(context.credential?.payload.token).toEqualTypeOf<string | undefined>()
-      expectTypeOf(context.envelope?.challenge.intent).toEqualTypeOf<'charge' | undefined>()
-      expectTypeOf(context.receipt.status).toEqualTypeOf<'success'>()
-      expectTypeOf(context.request.recipient).toEqualTypeOf<string>()
-    })
-    mppx.onPaymentFailed((context) => {
-      expectTypeOf(context.credential).toMatchTypeOf<unknown>()
-      expectTypeOf(context.error).toMatchTypeOf<Error>()
-      expectTypeOf(context.method.intent).toEqualTypeOf<'charge'>()
-      expectTypeOf(context.request.currency).toEqualTypeOf<string>()
-    })
-  })
-
-  test('handler options and verifyCredential accept scope', () => {
-    const mppx = Mppx.create({ methods: [alphaMethod], realm, secretKey })
-
-    expectTypeOf(
-      mppx.charge({
-        amount: '100',
-        currency: '0x01',
-        decimals: 6,
-        recipient: '0x02',
-        scope: 'GET /premium',
-      }),
-    ).toBeFunction()
-
-    expectTypeOf(mppx.verifyCredential('credential', { scope: 'GET /premium' })).toMatchTypeOf<
-      Promise<unknown>
-    >()
-  })
-
-  test('tempo subscription accepts ergonomic date and period inputs', () => {
-    const method = tempo.subscription({
-      amount: '10',
-      currency: '0x20c0000000000000000000000000000000000001',
-      periodCount: 1,
-      periodUnit: 'day',
-      recipient: '0x1234567890abcdef1234567890abcdef12345678',
-      resolve: async () => ({ key: 'user-1:plan:pro' }),
-      subscriptionExpires: new Date('2026-01-01T00:00:00Z'),
-    })
-    const mppx = Mppx.create({ methods: [method], realm, secretKey })
-
-    expectTypeOf(
-      mppx.tempo.subscription({
-        expires: new Date('2026-01-01T00:00:00Z'),
-        periodCount: 1n,
-        subscriptionExpires: new Date('2026-01-01T00:00:00Z'),
-      }),
-    ).toBeFunction()
-  })
-
-  test('tempo factories expose resolved currency and decimals as defaults', () => {
-    const charge = Mppx.create({ methods: [tempo.charge()], realm, secretKey })
-    expectTypeOf(charge.tempo.charge({ amount: '1' })).toBeFunction()
-    // @ts-expect-error amount is not supplied by Tempo's runtime defaults.
-    void charge.tempo.charge({})
-
-    const subscription = Mppx.create({
-      methods: [
-        tempo.subscription({
-          recipient: '0x1234567890abcdef1234567890abcdef12345678',
-          resolve: async () => null,
-        }),
-      ],
-      realm,
-      secretKey,
-    })
-    expectTypeOf(
-      subscription.tempo.subscription({
-        amount: '1',
-        periodCount: 1n,
-        periodUnit: 'day',
-        subscriptionExpires: new Date('2026-01-01T00:00:00Z'),
-      }),
-    ).toBeFunction()
-
-    const session = Mppx.create({ methods: [tempo.session()], realm, secretKey })
-    expectTypeOf(session.tempo.session({ amount: '1', unitType: 'request' })).toBeFunction()
-
-    const common = Mppx.create({
-      methods: [
-        tempo.common({
-          amount: '1',
-          recipient: '0x1234567890abcdef1234567890abcdef12345678',
-        }),
-      ],
-      realm,
-      secretKey,
-    })
-    expectTypeOf(common.tempo.charge({})).toBeFunction()
-    expectTypeOf(common.tempo.session({ unitType: 'request' })).toBeFunction()
-  })
-})