mppx 0.0.1 → 0.1.1

package/src/middlewares/express.test.ts

@@ -0,0 +1,155 @@
+import express from 'express'
+import { Receipt } from 'mppx'
+import { Mppx as Mppx_client, session as sessionIntent, tempo as tempo_client } from 'mppx/client'
+import { Mppx } from 'mppx/express'
+import { tempo as tempo_server } from 'mppx/server'
+import type { Address } from 'viem'
+import { Addresses } from 'viem/tempo'
+import { beforeAll, describe, expect, test } from 'vitest'
+import { deployEscrow } from '~test/tempo/stream.js'
+import { accounts, asset, client, fundAccount } from '~test/tempo/viem.js'
+
+function createServer(app: express.Express) {
+  return new Promise<{ url: string; close: () => void }>((resolve) => {
+    const server = app.listen(0, () => {
+      const { port } = server.address() as { port: number }
+      resolve({
+        url: `http://localhost:${port}`,
+        close: () => server.close(),
+      })
+    })
+  })
+}
+
+describe('charge', () => {
+  const mppx = Mppx.create({
+    methods: [
+      tempo_server({
+        getClient: () => client,
+        currency: asset,
+        recipient: accounts[0].address,
+      }),
+    ],
+  })
+
+  const { fetch } = Mppx_client.create({
+    polyfill: false,
+    methods: [
+      tempo_client({
+        account: accounts[1],
+        getClient: () => client,
+      }),
+    ],
+  })
+
+  test('returns 402 when no credential', async () => {
+    const app = express()
+    app.get('/', mppx.charge({ amount: '1' }), (_req, res) => {
+      res.json({ fortune: 'You will be rich' })
+    })
+
+    const server = await createServer(app)
+    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 app = express()
+    app.get('/', mppx.charge({ amount: '1' }), (_req, res) => {
+      res.json({ fortune: 'You will be rich' })
+    })
+
+    const server = await createServer(app)
+    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 receiptHeader = response.headers.get('Payment-Receipt')
+    expect(receiptHeader).toBeTruthy()
+
+    const receipt = Receipt.fromResponse(response)
+    expect(receipt.status).toBe('success')
+    expect(receipt.method).toBe('tempo')
+
+    server.close()
+  })
+})
+
+describe('session', () => {
+  let escrowContract: Address
+
+  beforeAll(async () => {
+    escrowContract = await deployEscrow()
+    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 = Mppx.create({
+      methods: [
+        tempo_server.session({
+          getClient: () => client,
+          recipient: accounts[0].address,
+          currency: asset,
+          escrowContract,
+        }),
+      ],
+    })
+
+    const app = express()
+    app.get('/', mppx.session({ amount: '1', unitType: 'token' }), (_req, res) => {
+      res.json({ data: 'streamed' })
+    })
+
+    const server = await createServer(app)
+    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 mppx = Mppx.create({
+      methods: [
+        tempo_server.session({
+          getClient: () => client,
+          recipient: accounts[0].address,
+          currency: asset,
+          escrowContract,
+          feePayer: accounts[0],
+        }),
+      ],
+    })
+
+    const { fetch } = Mppx_client.create({
+      polyfill: false,
+      methods: [
+        sessionIntent({
+          account: accounts[2],
+          deposit: '10',
+          getClient: () => client,
+        }),
+      ],
+    })
+
+    const app = express()
+    app.get('/', mppx.session({ amount: '1', unitType: 'token' }), (_req, res) => {
+      res.json({ data: 'streamed' })
+    })
+
+    const server = await createServer(app)
+    const response = await fetch(server.url)
+    expect(response.status).toBe(200)
+
+    const body = await response.json()
+    expect(body).toEqual({ data: 'streamed' })
+
+    server.close()
+  })
+})

package/src/middlewares/express.ts

@@ -0,0 +1,82 @@
+import type {
+  Request as ExpressRequest,
+  Response as ExpressResponse,
+  NextFunction,
+  RequestHandler,
+} from 'express'
+import * as Mppx_core from '../server/Mppx.js'
+import * as Request from '../server/Request.js'
+import * as Mppx_internal from './internal/mppx.js'
+
+export * from '../server/Methods.js'
+
+export namespace Mppx {
+  /**
+   * Creates an Express-aware payment handler where each intent
+   * returns an Express `RequestHandler`.
+   *
+   * @example
+   * ```ts
+   * import express from 'express'
+   * import { Mppx, tempo } from 'mppx/express'
+   *
+   * const app = express()
+   * const mppx = Mppx.create({ methods: [tempo()] })
+   *
+   * app.get('/premium', mppx.charge({ amount: '1' }), (req, res) => {
+   *   res.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>, RequestHandler> {
+    return Mppx_internal.wrap(Mppx_core.create(config), payment)
+  }
+}
+
+/**
+ * Express middleware 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
+ * import express from 'express'
+ * import { Mppx } from 'mppx/server'
+ * import { payment } from 'mppx/express'
+ *
+ * const mppx = Mppx.create({ methods: [tempo()] })
+ *
+ * const app = express()
+ * app.get('/premium', payment(mppx.charge, { amount: '1' }), (req, res) => {
+ *   res.json({ data: 'paid content' })
+ * })
+ * ```
+ */
+export function payment<const intent extends Mppx_internal.AnyIntentFn>(
+  intent: intent,
+  options: intent extends (options: infer options) => any ? options : never,
+): RequestHandler {
+  return async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+    const result = await intent(options)(Request.fromNodeListener(req, res))
+
+    if (result.status === 402) {
+      const challenge = result.challenge as Response
+      res.status(challenge.status)
+      for (const [key, value] of challenge.headers) res.setHeader(key, value)
+      res.send(await challenge.text())
+      return
+    }
+
+    const originalJson = res.json.bind(res)
+    res.json = (body: any) => {
+      const wrapped = result.withReceipt(Response.json(body))
+      res.setHeader('Payment-Receipt', wrapped.headers.get('Payment-Receipt')!)
+      return originalJson(body)
+    }
+
+    next()
+  }
+}

package/src/middlewares/hono.test.ts

@@ -0,0 +1,148 @@
+import { serve } from '@hono/node-server'
+import { Hono } from 'hono'
+import { Receipt } from 'mppx'
+import { Mppx as Mppx_client, session as sessionIntent, tempo as tempo_client } from 'mppx/client'
+import { Mppx } from 'mppx/hono'
+import { tempo as tempo_server } from 'mppx/server'
+import type { Address } from 'viem'
+import { Addresses } from 'viem/tempo'
+import { beforeAll, describe, expect, test } from 'vitest'
+import { deployEscrow } from '~test/tempo/stream.js'
+import { accounts, asset, client, fundAccount } from '~test/tempo/viem.js'
+
+function createServer(app: Hono) {
+  return new Promise<{ url: string; close: () => void }>((resolve) => {
+    const server = serve({ fetch: app.fetch, port: 0 }, (info) => {
+      resolve({
+        url: `http://localhost:${info.port}`,
+        close: () => server.close(),
+      })
+    })
+  })
+}
+
+describe('charge', () => {
+  const mppx = Mppx.create({
+    methods: [
+      tempo_server.charge({
+        getClient: () => client,
+        currency: asset,
+        recipient: accounts[0].address,
+      }),
+    ],
+  })
+
+  const { fetch } = Mppx_client.create({
+    polyfill: false,
+    methods: [
+      tempo_client.charge({
+        account: accounts[1],
+        getClient: () => client,
+      }),
+    ],
+  })
+
+  test('returns 402 when no credential', async () => {
+    const app = new Hono()
+    app.get('/', mppx.charge({ amount: '1' }), (c) => c.json({ fortune: 'You will be rich' }))
+
+    const server = await createServer(app)
+    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 app = new Hono()
+    app.get('/', mppx.charge({ amount: '1' }), (c) => c.json({ fortune: 'You will be rich' }))
+
+    const server = await createServer(app)
+    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()
+  })
+})
+
+describe('session', () => {
+  let escrowContract: Address
+
+  beforeAll(async () => {
+    escrowContract = await deployEscrow()
+    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 = Mppx.create({
+      methods: [
+        tempo_server.session({
+          getClient: () => client,
+          recipient: accounts[0].address,
+          currency: asset,
+          escrowContract,
+        }),
+      ],
+    })
+
+    const app = new Hono()
+    app.get('/', mppx.session({ amount: '1', unitType: 'token' }), (c) =>
+      c.json({ data: 'streamed' }),
+    )
+
+    const server = await createServer(app)
+    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 mppx = Mppx.create({
+      methods: [
+        tempo_server.session({
+          getClient: () => client,
+          recipient: accounts[0].address,
+          currency: asset,
+          escrowContract,
+          feePayer: accounts[0],
+        }),
+      ],
+    })
+
+    const { fetch } = Mppx_client.create({
+      polyfill: false,
+      methods: [
+        sessionIntent({
+          account: accounts[2],
+          deposit: '10',
+          getClient: () => client,
+        }),
+      ],
+    })
+
+    const app = new Hono()
+    app.get('/', mppx.session({ amount: '1', unitType: 'token' }), (c) =>
+      c.json({ data: 'streamed' }),
+    )
+
+    const server = await createServer(app)
+    const response = await fetch(server.url)
+    expect(response.status).toBe(200)
+
+    const body = await response.json()
+    expect(body).toEqual({ data: 'streamed' })
+
+    server.close()
+  })
+})

package/src/middlewares/hono.ts

@@ -0,0 +1,62 @@
+import type { MiddlewareHandler } from 'hono'
+import * as Mppx_core from '../server/Mppx.js'
+import * as Mppx_internal from './internal/mppx.js'
+
+export * from '../server/Methods.js'
+
+export namespace Mppx {
+  /**
+   * Creates a Hono-aware payment handler where each intent
+   * returns a Hono `MiddlewareHandler`.
+   *
+   * @example
+   * ```ts
+   * import { Hono } from 'hono'
+   * import { Mppx, tempo } from 'mppx/hono'
+   *
+   * const app = new Hono()
+   * const mppx = Mppx.create({ methods: [tempo()] })
+   *
+   * app.get('/premium', mppx.charge({ amount: '1' }), (c) =>
+   *   c.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>, MiddlewareHandler> {
+    return Mppx_internal.wrap(Mppx_core.create(config), payment)
+  }
+}
+
+/**
+ * Hono middleware 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
+ * import { Hono } from 'hono'
+ * import { Mppx } from 'mppx/server'
+ * import { payment } from 'mppx/hono'
+ *
+ * const mppx = Mppx.create({ methods: [tempo()] })
+ *
+ * const app = new Hono()
+ * app.get('/premium', payment(mppx.charge, { amount: '1' }), (c) =>
+ *   c.json({ data: 'paid content' }),
+ * )
+ * ```
+ */
+export function payment<const intent extends Mppx_internal.AnyIntentFn>(
+  intent: intent,
+  options: intent extends (options: infer options) => any ? options : never,
+): MiddlewareHandler {
+  return async (c, next) => {
+    const result = await intent(options)(c.req.raw)
+    if (result.status === 402) return result.challenge
+    await next()
+    c.res = result.withReceipt(c.res)
+  }
+}

package/src/middlewares/internal/mppx.ts

@@ -0,0 +1,30 @@
+import type * as MethodIntent from '../../MethodIntent.js'
+import type * as Mppx from '../../server/Mppx.js'
+
+export type AnyIntentFn = Mppx.AnyIntentFn
+export type AnyServer = MethodIntent.AnyServer
+
+export type Wrap<mppx, handler> = {
+  [key in keyof mppx]: mppx[key] extends (options: infer options) => any
+    ? (o: options) => handler
+    : mppx[key]
+}
+
+/**
+ * Wraps a payment handler so each intent returns a framework-specific
+ * handler instead of the raw intent response.
+ *
+ * @param mppx - The payment handler created by `Mppx.create`.
+ * @param wrapper - A function that adapts an intent function into a framework handler.
+ */
+export function wrap<mppx extends Mppx.Mppx<any, any>, handler>(
+  mppx: mppx,
+  wrapper: (intent: AnyIntentFn, options: any) => handler,
+): Wrap<mppx, handler> {
+  const result: Record<string, unknown> = { ...mppx }
+  for (const mi of mppx.methods as readonly MethodIntent.AnyServer[]) {
+    const intentFn = (mppx as any)[mi.name]
+    result[mi.name] = (options: any) => wrapper(intentFn, options)
+  }
+  return result as never
+}

package/src/middlewares/nextjs.test.ts

@@ -0,0 +1,164 @@
+import * as http from 'node:http'
+import { Receipt } from 'mppx'
+import { Mppx as Mppx_client, session as sessionIntent, tempo as tempo_client } from 'mppx/client'
+import { Mppx } from 'mppx/nextjs'
+import { tempo as tempo_server } from 'mppx/server'
+import type { Address } from 'viem'
+import { Addresses } from 'viem/tempo'
+import { beforeAll, describe, expect, test } from 'vitest'
+import { deployEscrow } from '~test/tempo/stream.js'
+import { accounts, asset, client, fundAccount } from '~test/tempo/viem.js'
+
+function createServer(handler: (request: Request) => Promise<Response> | Response) {
+  return new Promise<{ url: string; close: () => void }>((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({
+        url: `http://localhost:${port}`,
+        close: () => server.close(),
+      })
+    })
+  })
+}
+
+describe('charge', () => {
+  const mppx = Mppx.create({
+    methods: [
+      tempo_server.charge({
+        getClient: () => client,
+        currency: asset,
+        recipient: accounts[0].address,
+      }),
+    ],
+  })
+
+  const { fetch } = Mppx_client.create({
+    polyfill: false,
+    methods: [
+      tempo_client.charge({
+        account: accounts[1],
+        getClient: () => client,
+      }),
+    ],
+  })
+
+  test('returns 402 when no credential', async () => {
+    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 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()
+  })
+})
+
+describe('session', () => {
+  let escrowContract: Address
+
+  beforeAll(async () => {
+    escrowContract = await deployEscrow()
+    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 = Mppx.create({
+      methods: [
+        tempo_server.session({
+          getClient: () => client,
+          recipient: accounts[0].address,
+          currency: asset,
+          escrowContract,
+        }),
+      ],
+    })
+
+    const handler = mppx.session({ amount: '1', 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 mppx = Mppx.create({
+      methods: [
+        tempo_server.session({
+          getClient: () => client,
+          recipient: accounts[0].address,
+          currency: asset,
+          escrowContract,
+          feePayer: accounts[0],
+        }),
+      ],
+    })
+
+    const { fetch } = Mppx_client.create({
+      polyfill: false,
+      methods: [
+        sessionIntent({
+          account: accounts[2],
+          deposit: '10',
+          getClient: () => client,
+        }),
+      ],
+    })
+
+    const handler = mppx.session({ amount: '1', 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()
+  })
+})