mppx 0.0.1 → 0.1.0

package/src/proxy/internal/Route.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, test } from 'vitest'
+
+import * as Route from './Route.js'
+
+describe('pathname', () => {
+  test('behavior: returns pathname without basePath', () => {
+    expect(
+      Route.pathname(new URL('http://localhost/api/proxy/openai/v1/models'), '/api/proxy'),
+    ).toBe('/openai/v1/models')
+  })
+
+  test('behavior: handles basePath with trailing slash', () => {
+    expect(
+      Route.pathname(new URL('http://localhost/api/proxy/stripe/v1/charges'), '/api/proxy/'),
+    ).toBe('/stripe/v1/charges')
+  })
+
+  test('behavior: returns pathname as-is when no basePath', () => {
+    expect(Route.pathname(new URL('http://localhost/openai/v1/models'))).toBe('/openai/v1/models')
+  })
+
+  test('error: returns null when basePath does not match', () => {
+    expect(
+      Route.pathname(new URL('http://localhost/other/openai/v1/models'), '/api/proxy'),
+    ).toBeNull()
+  })
+})
+
+describe('parse', () => {
+  test('behavior: extracts serviceId and upstreamPath', () => {
+    expect(Route.parse('/openai/v1/chat/completions')).toMatchInlineSnapshot(`
+      {
+        "serviceId": "openai",
+        "upstreamPath": "/v1/chat/completions",
+      }
+    `)
+  })
+
+  test('behavior: parses anthropic service path', () => {
+    expect(Route.parse('/anthropic/v1/messages')).toMatchInlineSnapshot(`
+      {
+        "serviceId": "anthropic",
+        "upstreamPath": "/v1/messages",
+      }
+    `)
+  })
+
+  test('behavior: returns root upstreamPath when no sub-path', () => {
+    expect(Route.parse('/stripe')).toMatchInlineSnapshot(`
+      {
+        "serviceId": "stripe",
+        "upstreamPath": "/",
+      }
+    `)
+  })
+
+  test('error: returns null for root path', () => {
+    expect(Route.parse('/')).toBeNull()
+  })
+
+  test('error: returns null for empty pathname', () => {
+    expect(Route.parse('')).toBeNull()
+  })
+})
+
+describe('match', () => {
+  test('behavior: matches exact method and path', () => {
+    const routes = { 'POST /v1/chat/completions': 'chat' }
+    const result = Route.match(routes, 'POST', '/v1/chat/completions')
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "key": "POST /v1/chat/completions",
+        "value": "chat",
+      }
+    `)
+  })
+
+  test('behavior: matches wildcard pattern', () => {
+    const routes = { 'POST /v1/images/*': 'images' }
+    const result = Route.match(routes, 'POST', '/v1/images/generations')
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "key": "POST /v1/images/*",
+        "value": "images",
+      }
+    `)
+  })
+
+  test('behavior: method-less pattern matches any method', () => {
+    const routes = { '/v1/*': 'catchall' }
+    expect(Route.match(routes, 'GET', '/v1/models')).toMatchInlineSnapshot(`
+      {
+        "key": "/v1/*",
+        "value": "catchall",
+      }
+    `)
+    expect(Route.match(routes, 'POST', '/v1/completions')).toMatchInlineSnapshot(`
+      {
+        "key": "/v1/*",
+        "value": "catchall",
+      }
+    `)
+  })
+
+  test('behavior: matches named params', () => {
+    const routes = { 'GET /v1/users/:id': 'user' }
+    const result = Route.match(routes, 'GET', '/v1/users/123')
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "key": "GET /v1/users/:id",
+        "value": "user",
+      }
+    `)
+  })
+
+  test('behavior: first match wins', () => {
+    const routes = {
+      'POST /v1/chat/completions': 'specific',
+      'POST /v1/*': 'general',
+    }
+    expect(Route.match(routes, 'POST', '/v1/chat/completions')?.value).toBe('specific')
+  })
+
+  test('behavior: case insensitive method matching', () => {
+    const routes = { 'POST /v1/chat': 'chat' }
+    expect(Route.match(routes, 'post', '/v1/chat')).toMatchInlineSnapshot(`
+      {
+        "key": "POST /v1/chat",
+        "value": "chat",
+      }
+    `)
+  })
+
+  test('error: returns null when no match', () => {
+    const routes = { 'POST /v1/chat/completions': 'chat' }
+    expect(Route.match(routes, 'POST', '/v2/unknown')).toBeNull()
+  })
+
+  test('error: returns null for wrong method', () => {
+    const routes = { 'POST /v1/chat/completions': 'chat' }
+    expect(Route.match(routes, 'GET', '/v1/chat/completions')).toBeNull()
+  })
+})

package/src/proxy/internal/Route.ts

@@ -0,0 +1,54 @@
+const httpMethods = new Set(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'])
+
+export function pathname(url: URL, basePath?: string): string | null {
+  let pathname = url.pathname
+  if (basePath) {
+    const base = basePath.replace(/\/+$/, '')
+    if (!pathname.startsWith(base)) return null
+    pathname = pathname.slice(base.length)
+  }
+  return pathname
+}
+
+export function parse(pathname: string): { serviceId: string; upstreamPath: string } | null {
+  const segments = pathname.split('/').filter(Boolean)
+  const serviceId = segments[0]
+  if (!serviceId) return null
+
+  const upstreamPath = `/${segments.slice(1).join('/')}`
+  return { serviceId, upstreamPath }
+}
+
+export function match(
+  routes: Record<string, unknown>,
+  method: string,
+  path: string,
+): { key: string; value: unknown } | null {
+  for (const [key, value] of Object.entries(routes)) {
+    const { method: routeMethod, pattern } = parseRouteKey(key)
+    if (routeMethod && routeMethod !== method.toUpperCase()) continue
+    const urlPattern = new URLPattern({ pathname: pattern })
+    if (urlPattern.test({ pathname: path })) return { key, value }
+  }
+  return null
+}
+
+export function matchPath(
+  routes: Record<string, unknown>,
+  path: string,
+): { key: string; value: unknown } | null {
+  for (const [key, value] of Object.entries(routes)) {
+    const { pattern } = parseRouteKey(key)
+    const urlPattern = new URLPattern({ pathname: pattern })
+    if (urlPattern.test({ pathname: path })) return { key, value }
+  }
+  return null
+}
+
+function parseRouteKey(key: string): { method: string | undefined; pattern: string } {
+  const tokens = key.trim().split(/\s+/)
+  if (tokens.length >= 2 && httpMethods.has(tokens[0]!.toUpperCase())) {
+    return { method: tokens[0]!.toUpperCase(), pattern: tokens.slice(1).join(' ') }
+  }
+  return { method: undefined, pattern: key }
+}

package/src/proxy/services/anthropic.ts

@@ -0,0 +1,45 @@
+import * as Service from '../Service.js'
+
+/**
+ * Creates an Anthropic service definition.
+ *
+ * Injects `x-api-key` header for upstream authentication.
+ * Per-endpoint `apiKey` overrides are supported via `options`.
+ *
+ * @example
+ * ```ts
+ * anthropic({
+ *   apiKey: 'sk-ant-...',
+ *   routes: {
+ *     'POST /v1/messages': mppx.charge({ amount: '0.03' }),
+ *     'POST /v1/complete': mppx.charge({ amount: '0.02' }),
+ *   },
+ * })
+ * ```
+ */
+export function anthropic(config: anthropic.Config) {
+  return Service.from<anthropic.Config>('anthropic', {
+    baseUrl: config.baseUrl ?? 'https://api.anthropic.com',
+    rewriteRequest(request, ctx) {
+      const apiKey = ctx.apiKey ?? config.apiKey
+      request.headers.set('x-api-key', apiKey)
+      return request
+    },
+    routes: config.routes,
+  })
+}
+
+export declare namespace anthropic {
+  export type Config = Service.From<{
+    /** Anthropic API key. Used as `x-api-key` header. */
+    apiKey: string
+    /** Base URL override. Defaults to `'https://api.anthropic.com'`. */
+    baseUrl?: string | undefined
+    routes:
+      | 'POST /v1/messages'
+      | 'POST /v1/messages/batches'
+      | 'GET /v1/messages/batches'
+      | 'GET /v1/messages/batches/:batchId'
+      | 'POST /v1/complete'
+  }>
+}

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

@@ -0,0 +1,97 @@
+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 'vitest'
+import * as Http from '~test/Http.js'
+import { accounts, asset, client } from '~test/tempo/viem.js'
+import * as ApiProxy from '../Proxy.js'
+import { openai } from './openai.js'
+
+const apiKey = process.env.VITE_OPENAI_API_KEY
+if (!apiKey) console.warn('OPENAI_API_KEY not set — openai proxy tests will be skipped')
+
+const mppx_server = Mppx_server.create({
+  methods: [
+    tempo_server({
+      account: accounts[0],
+      currency: asset,
+      getClient: () => client,
+    }),
+  ],
+})
+
+const mppx_client = Mppx_client.create({
+  polyfill: false,
+  methods: [
+    tempo_client({
+      account: accounts[1],
+      getClient: () => client,
+    }),
+  ],
+})
+
+let proxyServer: Awaited<ReturnType<typeof Http.createServer>> | undefined
+
+afterEach(() => proxyServer?.close())
+
+describe.skipIf(!apiKey)('openai', () => {
+  test('behavior: proxies GET /v1/models with charge', async () => {
+    const proxy = ApiProxy.create({
+      services: [
+        openai({
+          apiKey: apiKey!,
+          routes: {
+            'GET /v1/models': mppx_server.charge({ amount: '1', decimals: 6 }),
+          },
+        }),
+      ],
+    })
+    proxyServer = await Http.createServer(proxy.listener)
+
+    const res = await mppx_client.fetch(`${proxyServer.url}/openai/v1/models`)
+    expect(res.status).toBe(200)
+
+    const body = (await res.json()) as { data: unknown[] }
+    expect(body.data).toBeDefined()
+    expect(Array.isArray(body.data)).toBe(true)
+
+    const receipt = Receipt.fromResponse(res)
+    expect(receipt.status).toBe('success')
+    expect(receipt.method).toBe('tempo')
+  })
+
+  test('behavior: returns 402 without credential', async () => {
+    const proxy = ApiProxy.create({
+      services: [
+        openai({
+          apiKey: apiKey!,
+          routes: {
+            'GET /v1/models': mppx_server.charge({ amount: '1', decimals: 6 }),
+          },
+        }),
+      ],
+    })
+    proxyServer = await Http.createServer(proxy.listener)
+
+    const res = await fetch(`${proxyServer.url}/openai/v1/models`)
+    expect(res.status).toBe(402)
+    expect(res.headers.get('WWW-Authenticate')).toContain('Payment')
+  })
+
+  test('behavior: returns 404 for unmatched route', async () => {
+    const proxy = ApiProxy.create({
+      services: [
+        openai({
+          apiKey: apiKey!,
+          routes: {
+            'GET /v1/models': mppx_server.charge({ amount: '1', decimals: 6 }),
+          },
+        }),
+      ],
+    })
+    proxyServer = await Http.createServer(proxy.listener)
+
+    const res = await fetch(`${proxyServer.url}/openai/v1/unknown`)
+    expect(res.status).toBe(404)
+  })
+})

package/src/proxy/services/openai.ts

@@ -0,0 +1,48 @@
+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',
+    rewriteRequest(request, ctx) {
+      const apiKey = ctx.apiKey ?? config.apiKey
+      request.headers.set('Authorization', `Bearer ${apiKey}`)
+      return request
+    },
+    routes: config.routes,
+  })
+}
+
+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
+    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.ts

@@ -0,0 +1,49 @@
+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',
+    rewriteRequest(request, ctx) {
+      const apiKey = ctx.apiKey ?? config.apiKey
+      request.headers.set('Authorization', `Basic ${btoa(`${apiKey}:`)}`)
+      return request
+    },
+    routes: config.routes,
+  })
+}
+
+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.ts

@@ -0,0 +1,2 @@
+export { stripe } from '../stripe/server/MethodIntents.js'
+export { tempo } from '../tempo/server/MethodIntents.js'