mppx 0.3.15 → 0.4.0

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

@@ -0,0 +1,152 @@
+import { Challenge, Credential, Method, z } from 'mppx'
+import { Mppx } from 'mppx/server'
+import { describe, expect, test } from 'vitest'
+import { wrap } from './mppx.js'
+
+const realm = 'api.example.com'
+const secretKey = 'test-secret-key'
+
+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 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)
+  })
+})

package/src/middlewares/internal/mppx.ts

@@ -4,10 +4,27 @@ import type * as Mppx from '../../server/Mppx.js'
 export type AnyMethodFn = Mppx.AnyMethodFn
 export type AnyServer = Method.AnyServer
 
-export type Wrap<mppx, handler> = {
-  [key in keyof mppx]: mppx[key] extends (options: infer options) => any
+/** Recursively wraps nested handler objects one level deep. */
+type WrapNested<obj, handler> = {
+  [key in keyof obj]: obj[key] extends (options: infer options) => any
     ? (o: options) => handler
-    : mppx[key]
+    : obj[key]
+}
+
+export type Wrap<mppx, handler> = {
+  // `compose` is omitted — it returns a raw HTTP handler, not a
+  // middleware-shaped result. Use `Mppx.compose()` static instead.
+  // `methods`, `realm`, `transport` are data properties — not handlers.
+  [key in keyof mppx as key extends 'compose' ? never : key]: key extends
+    | 'methods'
+    | 'realm'
+    | 'transport'
+    ? mppx[key]
+    : mppx[key] extends (options: infer options) => any
+      ? (o: options) => handler
+      : mppx[key] extends Record<string, (options: any) => any>
+        ? WrapNested<mppx[key], handler>
+        : mppx[key]
 }
 
 /**
@@ -21,13 +38,19 @@ export function wrap<mppx extends Mppx.Mppx<any, any>, handler>(
   mppx: mppx,
   wrapper: (method: AnyMethodFn, options: any) => handler,
 ): Wrap<mppx, handler> {
-  const result: Record<string, unknown> = { ...mppx }
+  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]
     result[key] = (options: any) => wrapper(methodFn, options)
     // Also set shorthand intent key if Mppx registered it (no collision)
     if ((mppx as any)[mi.intent]) result[mi.intent] = (options: any) => wrapper(methodFn, options)
+    // 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] = (options: any) =>
+      wrapper(methodFn, options)
   }
   return result as never
 }

package/src/proxy/Service.ts

@@ -267,7 +267,8 @@ function resolvePayment(endpoint: Endpoint): Record<string, unknown> | null {
   if (endpoint === true) return null
   const handler = typeof endpoint === 'function' ? endpoint : endpoint.pay
   if (!('_internal' in handler)) return {}
-  const { name, intent, defaults, schema, ...rest } = handler._internal as Record<string, unknown>
+  const { name, intent, defaults, schema, _canonicalRequest, ...rest } =
+    handler._internal as Record<string, unknown>
   const amount = (() => {
     if (typeof rest.amount === 'string' && typeof rest.decimals === 'number')
       return String(Value.from(rest.amount, rest.decimals))

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

@@ -1,20 +1,13 @@
-import { tempo } from 'mppx/server'
-import { createClient, http } from 'viem'
-import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
-import { describe, expectTypeOf, test } from 'vitest'
-import * as Method from '../Method.js'
-import * as z from '../zod.js'
-import * as Mppx from './Mppx.js'
+import { Method, z } from 'mppx'
+import { Mppx } from 'mppx/server'
+import { assertType, describe, expectTypeOf, test } from 'vitest'
 
-const account = privateKeyToAccount(generatePrivateKey())
-const getClient = () => createClient({ account, transport: http() })
-
-const fooCharge = Method.from({
-  name: 'test',
+const mockChargeA = Method.from({
+  name: 'alpha',
   intent: 'charge',
   schema: {
     credential: {
-      payload: z.object({ signature: z.string() }),
+      payload: z.object({ token: z.string() }),
     },
     request: z.object({
       amount: z.string(),
@@ -25,317 +18,119 @@ const fooCharge = Method.from({
   },
 })
 
-describe('Mppx', () => {
-  test('has methods and realm properties', () => {
-    const method = Method.toServer(fooCharge, {
-      async verify() {
-        return {
-          method: 'test',
-          reference: '0x123',
-          status: 'success' as const,
-          timestamp: new Date().toISOString(),
-        }
-      },
-    })
-
-    const handler = Mppx.create({
-      methods: [method],
-      realm: 'api.example.com',
-      secretKey: 'secret',
-    })
-
-    expectTypeOf(handler.methods).toEqualTypeOf([method] as const)
-    expectTypeOf(handler.realm).toBeString()
-  })
-
-  test('has method functions matching methods', () => {
-    const method = Method.toServer(fooCharge, {
-      async verify() {
-        return {
-          method: 'test',
-          reference: '0x123',
-          status: 'success' as const,
-          timestamp: new Date().toISOString(),
-        }
-      },
-    })
+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 handler = Mppx.create({
-      methods: [method],
-      realm: 'api.example.com',
-      secretKey: 'secret',
-    })
+const alphaMethod = Method.toServer(mockChargeA, {
+  async verify() {
+    return {
+      method: 'alpha',
+      reference: 'tx',
+      status: 'success' as const,
+      timestamp: new Date().toISOString(),
+    }
+  },
+})
 
-    expectTypeOf(handler.charge).toBeFunction()
-  })
+const betaMethod = Method.toServer(mockChargeB, {
+  async verify() {
+    return {
+      method: 'beta',
+      reference: 'tx',
+      status: 'success' as const,
+      timestamp: new Date().toISOString(),
+    }
+  },
+})
 
-  test('method function options include request', () => {
-    const method = Method.toServer(fooCharge, {
-      async verify() {
-        return {
-          method: 'test',
-          reference: '0x123',
-          status: 'success' as const,
-          timestamp: new Date().toISOString(),
-        }
-      },
-    })
+const secretKey = 'test-secret'
+const realm = 'api.example.com'
 
-    const handler = Mppx.create({
-      methods: [method],
-      realm: 'api.example.com',
-      secretKey: 'secret',
-    })
+describe('Mppx type tests', () => {
+  test('compose exists on the instance and returns a handler', () => {
+    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
 
-    handler.charge({
-      amount: '1000',
-      currency: '0x1234',
-      decimals: 6,
-      expires: '2025-01-01T00:00:00Z',
-      recipient: '0xabc',
-    })
+    expectTypeOf(mppx.compose).toBeFunction()
   })
 
-  test('method function returns handler that accepts Request', async () => {
-    const method = Method.toServer(fooCharge, {
-      async verify() {
-        return {
-          method: 'test',
-          reference: '0x123',
-          status: 'success' as const,
-          timestamp: new Date().toISOString(),
-        }
-      },
-    })
-
-    const handler = Mppx.create({
-      methods: [method],
-      realm: 'api.example.com',
-      secretKey: 'secret',
-    })
+  test('compose accepts method reference tuples', () => {
+    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
 
-    const chargeHandler = handler.charge({
-      amount: '1000',
-      currency: '0x1234',
+    const opts = {
+      amount: '100',
+      currency: '0x01',
       decimals: 6,
-      expires: '2025-01-01T00:00:00Z',
-      recipient: '0xabc',
-    })
-
-    const result = await chargeHandler(new Request('https://example.com'))
-
-    if (result.status === 402) {
-      expectTypeOf(result.challenge).toEqualTypeOf<Response>()
-    } else {
-      expectTypeOf(result.withReceipt).toBeFunction()
+      recipient: '0x02',
     }
-  })
-
-  test('multiple methods', () => {
-    const fooAuthorize = Method.from({
-      name: 'test',
-      intent: 'authorize',
-      schema: {
-        credential: {
-          payload: z.object({ token: z.string() }),
-        },
-        request: z.object({
-          scope: z.string(),
-          duration: z.number(),
-        }),
-      },
-    })
 
-    const chargeMethod = Method.toServer(fooCharge, {
-      defaults: {
-        currency: '0x1234',
-        recipient: '0xabc',
-      },
-      async verify() {
-        return {
-          method: 'test',
-          reference: '0x123',
-          status: 'success' as const,
-          timestamp: new Date().toISOString(),
-        }
-      },
-    })
-
-    const authorizeMethod = Method.toServer(fooAuthorize, {
-      async verify() {
-        return {
-          method: 'test',
-          reference: '0x456',
-          status: 'success' as const,
-          timestamp: new Date().toISOString(),
-        }
-      },
-    })
+    // Should compile — method reference entries
+    const handler = mppx.compose([alphaMethod, opts], [betaMethod, opts])
+    expectTypeOf(handler).toBeFunction()
+  })
 
-    const handler = Mppx.create({
-      methods: [chargeMethod, authorizeMethod],
-      realm: 'api.example.com',
-      secretKey: 'secret',
-    })
+  test('compose accepts string key tuples', () => {
+    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
 
-    handler.charge({
-      amount: '1000',
-      currency: '0x1234',
+    const opts = {
+      amount: '100',
+      currency: '0x01',
       decimals: 6,
-      recipient: '0xabc',
-    })
+      recipient: '0x02',
+    }
 
-    handler.authorize({
-      scope: 'read',
-      duration: 3600,
-    })
+    // Should compile — string key entries
+    const handler = mppx.compose(['alpha/charge', opts], ['beta/charge', opts])
+    expectTypeOf(handler).toBeFunction()
   })
 
-  describe('defaults', () => {
-    test('defaulted fields are optional in method options', () => {
-      const handler = Mppx.create({
-        methods: [tempo({ currency: '0x1234', recipient: '0xabc', getClient })],
-        realm: 'api.example.com',
-        secretKey: 'secret',
-      })
-
-      // currency and recipient should be optional since they're in defaults
-      handler.charge({
-        amount: '1000',
-        decimals: 6,
-      })
-
-      // But can still be overridden
-      handler.charge({
-        amount: '1000',
-        currency: '0x5678',
-        decimals: 6,
-        recipient: '0xdef',
-      })
-    })
-
-    test('non-defaulted fields remain required', () => {
-      const handler = Mppx.create({
-        methods: [tempo({ currency: '0x1234', getClient })],
-        realm: 'api.example.com',
-        secretKey: 'secret',
-      })
-
-      // recipient is still required since it's not in defaults
-      handler.charge({
-        amount: '1000',
-        decimals: 6,
-        recipient: '0xabc',
-      })
-    })
-
-    test('no defaults means all fields required', () => {
-      const handler = Mppx.create({
-        methods: [tempo({ getClient })],
-        realm: 'api.example.com',
-        secretKey: 'secret',
-      })
-
-      // All required fields must be provided
-      handler.charge({
-        amount: '1000',
-        currency: '0x1234',
-        decimals: 6,
-        recipient: '0xabc',
-      })
-    })
+  test('nested handlers are accessible', () => {
+    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
 
-    test('type: defaulted fields are optional in options type', () => {
-      const handler = Mppx.create({
-        methods: [tempo({ currency: '0x1234', recipient: '0xabc', getClient })],
-        realm: 'api.example.com',
-        secretKey: 'secret',
-      })
-
-      type ChargeOptions = Parameters<typeof handler.charge>[0]
-
-      // currency and recipient should be optional (include undefined)
-      expectTypeOf<ChargeOptions['currency']>().toEqualTypeOf<string | undefined>()
-      expectTypeOf<ChargeOptions['recipient']>().toEqualTypeOf<string | undefined>()
-
-      // amount should still be required (no undefined)
-      expectTypeOf<ChargeOptions['amount']>().toEqualTypeOf<string>()
-    })
-
-    test('account as Account defaults recipient', () => {
-      const handler = Mppx.create({
-        methods: [tempo.charge({ currency: '0x1234', account })],
-        realm: 'api.example.com',
-        secretKey: 'secret',
-      })
-
-      // recipient is defaulted via account, so it should be optional
-      handler.charge({
-        amount: '1000',
-        decimals: 6,
-      })
-
-      // can still override recipient
-      handler.charge({
-        amount: '1000',
-        decimals: 6,
-        recipient: '0xdef',
-      })
-    })
+    expectTypeOf(mppx.alpha).toBeObject()
+    expectTypeOf(mppx.alpha.charge).toBeFunction()
+    expectTypeOf(mppx.beta).toBeObject()
+    expectTypeOf(mppx.beta.charge).toBeFunction()
+  })
 
-    test('account as Account with feePayer: true', () => {
-      const handler = Mppx.create({
-        methods: [tempo.charge({ currency: '0x1234', account, feePayer: true })],
-        realm: 'api.example.com',
-        secretKey: 'secret',
-      })
+  test('slash key handlers are accessible', () => {
+    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
 
-      handler.charge({
-        amount: '1000',
-        decimals: 6,
-      })
-    })
+    expectTypeOf(mppx['alpha/charge']).toBeFunction()
+    expectTypeOf(mppx['beta/charge']).toBeFunction()
   })
 
-  describe('session getClient', () => {
-    test('tempo.session requires getClient', () => {
-      Mppx.create({
-        methods: [
-          tempo.session({
-            currency: '0x1234',
-            recipient: '0xabc',
-            getClient,
-          }),
-        ],
-        realm: 'api.example.com',
-        secretKey: 'secret',
-      })
-    })
+  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',
+    }
 
-    test('combined tempo() requires getClient', () => {
-      Mppx.create({
-        methods: [tempo({ currency: '0x1234', recipient: '0xabc', getClient })],
-        realm: 'api.example.com',
-        secretKey: 'secret',
-      })
-    })
+    const handler = mppx.compose([alphaMethod, opts])
+    type HandlerReturn = ReturnType<typeof handler>
 
-    test('tempo.charge does not require getClient', () => {
-      Mppx.create({
-        methods: [tempo.charge({ currency: '0x1234', recipient: '0xabc' })],
-        realm: 'api.example.com',
-        secretKey: 'secret',
-      })
-    })
+    assertType<Promise<{ status: 402; challenge: Response } | { status: 200; withReceipt: any }>>(
+      {} as Awaited<HandlerReturn> as any,
+    )
   })
-})
-
-describe('create.Config', () => {
-  test('requires methods, realm, and secretKey', () => {
-    type Config = Mppx.create.Config
 
-    expectTypeOf<Config>().toHaveProperty('methods')
-    expectTypeOf<Config>().toHaveProperty('realm')
-    expectTypeOf<Config>().toHaveProperty('secretKey')
+  test('static Mppx.compose accepts configured handlers', () => {
+    expectTypeOf(Mppx.compose).toBeFunction()
   })
 })