mppx 0.4.8 → 0.4.10

package/src/Store.test.ts

@@ -1,4 +1,5 @@
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
+
 import * as Store from './Store.js'
 
 const nested = {
@@ -7,16 +8,16 @@ const nested = {
   meta: { active: true, tags: ['a', 'b'] },
 }
 
-function fakeKv(): Store.cloudflare.Parameters {
+function fakeKv() {
   const map = new Map<string, string>()
   return {
-    async get(key) {
+    async get(key: string) {
       return map.get(key) ?? null
     },
-    async put(key, value) {
+    async put(key: string, value: string) {
       map.set(key, value)
     },
-    async delete(key) {
+    async delete(key: string) {
       map.delete(key)
     },
   }
@@ -25,6 +26,17 @@ function fakeKv(): Store.cloudflare.Parameters {
 describe.each([
   { label: 'memory', create: () => Store.memory() },
   { label: 'cloudflare', create: () => Store.cloudflare(fakeKv()) },
+  {
+    label: 'redis',
+    create: () => {
+      const kv = fakeKv()
+      return Store.redis({
+        get: kv.get,
+        set: kv.put,
+        del: (key) => kv.delete(key),
+      })
+    },
+  },
   {
     label: 'upstash',
     create: () => {
@@ -64,6 +76,20 @@ describe.each([
 })
 
 describe('json roundtrip behavior', () => {
+  test('cloudflare json-roundtrips nested objects', async () => {
+    const store = Store.cloudflare(fakeKv())
+    const value = { a: [1, { b: 'c' }], d: null }
+    await store.put('k', value)
+    expect(await store.get('k')).toEqual(value)
+  })
+
+  test('cloudflare roundtrips BigInt values', async () => {
+    const store = Store.cloudflare(fakeKv())
+    const value = { amount: 1000000000000000000n, nested: { big: 42n } }
+    await store.put('k', value)
+    expect(await store.get('k')).toEqual(value)
+  })
+
   test('memory json-roundtrips nested objects', async () => {
     const store = Store.memory()
     const value = { a: [1, { b: 'c' }], d: null }
@@ -71,13 +97,37 @@ describe('json roundtrip behavior', () => {
     expect(await store.get('k')).toEqual(value)
   })
 
-  test('cloudflare json-roundtrips nested objects', async () => {
-    const store = Store.cloudflare(fakeKv())
+  test('memory roundtrips BigInt values', async () => {
+    const store = Store.memory()
+    const value = { amount: 1000000000000000000n, nested: { big: 42n } }
+    await store.put('k', value)
+    expect(await store.get('k')).toEqual(value)
+  })
+
+  test('redis json-roundtrips nested objects', async () => {
+    const kv = fakeKv()
+    const store = Store.redis({
+      get: kv.get,
+      set: kv.put,
+      del: (key) => kv.delete(key),
+    })
     const value = { a: [1, { b: 'c' }], d: null }
     await store.put('k', value)
     expect(await store.get('k')).toEqual(value)
   })
 
+  test('redis roundtrips BigInt values', async () => {
+    const kv = fakeKv()
+    const store = Store.redis({
+      get: kv.get,
+      set: kv.put,
+      del: (key) => kv.delete(key),
+    })
+    const value = { amount: 1000000000000000000n, nested: { big: 42n } }
+    await store.put('k', value)
+    expect(await store.get('k')).toEqual(value)
+  })
+
   test('upstash passes values through without json serialization', async () => {
     const kv = fakeKv()
     const store = Store.upstash({

package/src/Store.ts

@@ -62,6 +62,31 @@ export function memory(): Store {
   })
 }
 
+/** Wraps a standard Redis client (ioredis, node-redis, Valkey). */
+export function redis(client: redis.Parameters): Store {
+  return from({
+    async get(key) {
+      const raw = await client.get(key)
+      if (raw == null) return null as any
+      return Json.parse(raw)
+    },
+    async put(key, value) {
+      await client.set(key, Json.stringify(value))
+    },
+    async delete(key) {
+      await client.del(key)
+    },
+  })
+}
+
+export declare namespace redis {
+  export type Parameters = {
+    get: (key: string) => Promise<string | null>
+    set: (key: string, value: string) => Promise<unknown>
+    del: (key: string) => Promise<unknown>
+  }
+}
+
 /** Wraps an Upstash Redis instance (e.g. Vercel KV). */
 export function upstash(redis: upstash.Parameters): Store {
   return from({

package/src/cli/account.ts

@@ -55,50 +55,85 @@ export function createKeychain(account = 'main') {
     async list(): Promise<string[]> {
       const platform = os.platform()
       if (platform === 'darwin') {
-          const { stdout, error } = await execCommand('security', ['dump-keychain'])
-          if (error) return []
-          const accounts: string[] = []
-          const blocks = stdout.split('keychain:')
-          for (const block of blocks) {
-            const serviceMatch = block.match(/"svce"<blob>="([^"]*)"/)
-            const accountMatch = block.match(/"acct"<blob>="([^"]*)"/)
-            if (serviceMatch?.[1] === service && accountMatch?.[1]) accounts.push(accountMatch[1])
-          }
-          return accounts
+        const { stdout, error } = await execCommand('security', ['dump-keychain'])
+        if (error) return []
+        const accounts: string[] = []
+        const blocks = stdout.split('keychain:')
+        for (const block of blocks) {
+          const serviceMatch = block.match(/"svce"<blob>="([^"]*)"/)
+          const accountMatch = block.match(/"acct"<blob>="([^"]*)"/)
+          if (serviceMatch?.[1] === service && accountMatch?.[1]) accounts.push(accountMatch[1])
+        }
+        return accounts
       }
       if (platform === 'linux') {
-          const { stdout, stderr, error } = await execCommand('secret-tool', ['search', '--all', '--unlock', 'service', service])
-          if (error) return []
-          const combined = `${stdout}\n${stderr}`
-          const accounts: string[] = []
-          const matches = combined.matchAll(/\baccount = (.+)/g)
-          for (const match of matches) if (match[1]) accounts.push(match[1])
-          return accounts
+        const { stdout, stderr, error } = await execCommand('secret-tool', [
+          'search',
+          '--all',
+          '--unlock',
+          'service',
+          service,
+        ])
+        if (error) return []
+        const combined = `${stdout}\n${stderr}`
+        const accounts: string[] = []
+        const matches = combined.matchAll(/\baccount = (.+)/g)
+        for (const match of matches) if (match[1]) accounts.push(match[1])
+        return accounts
       }
       throw new Error(`Unsupported platform: ${platform}`)
     },
     async get(): Promise<string | undefined> {
       const platform = os.platform()
       if (platform === 'darwin') {
-          const { stdout, error } = await execCommand('security', ['find-generic-password', '-s', service, '-a', account, '-w'])
-          return error ? undefined : stdout
+        const { stdout, error } = await execCommand('security', [
+          'find-generic-password',
+          '-s',
+          service,
+          '-a',
+          account,
+          '-w',
+        ])
+        return error ? undefined : stdout
       }
       if (platform === 'linux') {
-          const { stdout, error } = await execCommand('secret-tool', ['lookup', 'service', service, 'account', account])
-          return error ? undefined : stdout || undefined
+        const { stdout, error } = await execCommand('secret-tool', [
+          'lookup',
+          'service',
+          service,
+          'account',
+          account,
+        ])
+        return error ? undefined : stdout || undefined
       }
       throw new Error(`Unsupported platform: ${platform}`)
     },
     async set(value: string): Promise<void> {
       const platform = os.platform()
       if (platform === 'darwin') {
-          await execCommand('security', ['delete-generic-password', '-s', service, '-a', account])
-          const { error } = await execCommand('security', ['add-generic-password', '-s', service, '-a', account, '-w', value])
-          if (error) throw error
-          return
+        await execCommand('security', ['delete-generic-password', '-s', service, '-a', account])
+        const { error } = await execCommand('security', [
+          'add-generic-password',
+          '-s',
+          service,
+          '-a',
+          account,
+          '-w',
+          value,
+        ])
+        if (error) throw error
+        return
       }
       if (platform === 'linux') {
-        const proc = child.execFile('secret-tool', ['store', '--label', `${service} ${account}`, 'service', service, 'account', account])
+        const proc = child.execFile('secret-tool', [
+          'store',
+          '--label',
+          `${service} ${account}`,
+          'service',
+          service,
+          'account',
+          account,
+        ])
         proc.stdin?.write(value)
         proc.stdin?.end()
         return new Promise((resolve, reject) => {
@@ -114,12 +149,12 @@ export function createKeychain(account = 'main') {
     async delete(): Promise<void> {
       const platform = os.platform()
       if (platform === 'darwin') {
-          await execCommand('security', ['delete-generic-password', '-s', service, '-a', account])
-          return
+        await execCommand('security', ['delete-generic-password', '-s', service, '-a', account])
+        return
       }
       if (platform === 'linux') {
-          await execCommand('secret-tool', ['clear', 'service', service, 'account', account])
-          return
+        await execCommand('secret-tool', ['clear', 'service', service, 'account', account])
+        return
       }
       throw new Error(`Unsupported platform: ${platform}`)
     },

package/src/cli/cli.test.ts

@@ -2,18 +2,20 @@ import { spawnSync } from 'node:child_process'
 import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
+
 import { parseUnits } from 'viem'
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 import { Addresses } from 'viem/tempo'
-import { afterAll, describe, expect, test } from 'vitest'
+import { afterAll, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
 import { rpcUrl } from '~test/tempo/prool.js'
 import { deployEscrow } from '~test/tempo/session.js'
 import { accounts, asset, client, fundAccount } from '~test/tempo/viem.js'
+
 import * as Credential from '../Credential.js'
-import * as Store from '../Store.js'
 import * as Mppx_server from '../server/Mppx.js'
 import { toNodeListener } from '../server/Mppx.js'
+import * as Store from '../Store.js'
 import { stripe as stripe_server } from '../stripe/server/Methods.js'
 import { tempo } from '../tempo/server/Methods.js'
 import type { SessionCredentialPayload } from '../tempo/session/Types.js'
@@ -74,6 +76,217 @@ async function serve(argv: string[], options?: { env?: Record<string, string | u
   return { output, stderr, exitCode }
 }
 
+describe('discover validate', () => {
+  test('validates a local discovery document', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-discovery-'))
+    const file = path.join(dir, 'openapi.json')
+    fs.writeFileSync(
+      file,
+      JSON.stringify({
+        info: { title: 'Test', version: '1.0.0' },
+        openapi: '3.1.0',
+        paths: {
+          '/search': {
+            post: {
+              'x-payment-info': {
+                amount: '100',
+                intent: 'charge',
+                method: 'tempo',
+              },
+              requestBody: {
+                content: { 'application/json': { schema: { type: 'object' } } },
+              },
+              responses: {
+                '200': { description: 'OK' },
+                '402': { description: 'Payment Required' },
+              },
+            },
+          },
+        },
+      }),
+    )
+
+    const { output, exitCode } = await serve(['discover', 'validate', file])
+    expect(exitCode).toBeUndefined()
+    expect(output).toContain('Discovery document is valid.')
+  })
+
+  test('returns non-zero for invalid discovery documents', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-discovery-'))
+    const file = path.join(dir, 'openapi.json')
+    fs.writeFileSync(
+      file,
+      JSON.stringify({
+        info: { title: 'Test', version: '1.0.0' },
+        openapi: '3.1.0',
+        paths: {
+          '/search': {
+            post: {
+              'x-payment-info': {
+                amount: '100',
+                intent: 'charge',
+                method: 'tempo',
+              },
+              responses: {
+                '200': { description: 'OK' },
+              },
+            },
+          },
+        },
+      }),
+    )
+
+    const { output, exitCode } = await serve(['discover', 'validate', file])
+    expect(exitCode).toBe(1)
+    expect(output).toContain('[error]')
+    expect(output).toContain('402')
+  })
+
+  test(
+    'validates remote discovery documents and reports warnings',
+    { timeout: 20_000 },
+    async () => {
+      const body = JSON.stringify({
+        info: { title: 'Test', version: '1.0.0' },
+        openapi: '3.1.0',
+        paths: {
+          '/search': {
+            post: {
+              'x-payment-info': {
+                amount: '100',
+                intent: 'charge',
+                method: 'tempo',
+              },
+              responses: {
+                '200': { description: 'OK' },
+                '402': { description: 'Payment Required' },
+              },
+            },
+          },
+        },
+      })
+      const server = await Http.createServer((_req, res) => {
+        res.setHeader('Content-Type', 'application/json')
+        res.end(body)
+      })
+
+      try {
+        const { output, exitCode } = await serve(['discover', 'validate', server.url])
+        expect(exitCode).toBeUndefined()
+        expect(output).toContain('[warning]')
+        expect(output).toContain('requestBody')
+        expect(output).toContain('valid with 1 warning')
+      } finally {
+        server.close()
+      }
+    },
+  )
+
+  test(
+    'rejects oversized discovery documents via content-length',
+    { timeout: 20_000 },
+    async () => {
+      const server = await Http.createServer((_req, res) => {
+        res.setHeader('Content-Type', 'application/json')
+        res.setHeader('Content-Length', String(11 * 1024 * 1024))
+        res.end('{}')
+      })
+
+      try {
+        const { exitCode, output } = await serve(['discover', 'validate', server.url])
+        expect(exitCode).toBe(1)
+        expect(output).toContain('10 MB')
+      } finally {
+        server.close()
+      }
+    },
+  )
+})
+
+describe('discover generate', () => {
+  test('generates from a pre-built OpenAPI document module', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-generate-'))
+    const mod = path.join(dir, 'doc.mjs')
+    fs.writeFileSync(
+      mod,
+      `export default ${JSON.stringify({
+        openapi: '3.1.0',
+        info: { title: 'Test', version: '1.0.0' },
+        paths: {
+          '/pay': {
+            post: {
+              'x-payment-info': { amount: '100', intent: 'charge', method: 'tempo' },
+              responses: {
+                '200': { description: 'OK' },
+                '402': { description: 'Payment Required' },
+              },
+            },
+          },
+        },
+      })}`,
+    )
+
+    const { output, exitCode } = await serve(['discover', 'generate', mod])
+    expect(exitCode).toBeUndefined()
+    const doc = JSON.parse(output)
+    expect(doc.openapi).toBe('3.1.0')
+    expect(doc.paths['/pay'].post['x-payment-info'].amount).toBe('100')
+
+    fs.rmSync(dir, { recursive: true, force: true })
+  })
+
+  test('writes to file with --output', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-generate-'))
+    const mod = path.join(dir, 'doc.mjs')
+    const outFile = path.join(dir, 'openapi.json')
+    fs.writeFileSync(
+      mod,
+      `export default ${JSON.stringify({
+        openapi: '3.1.0',
+        info: { title: 'Test', version: '1.0.0' },
+        paths: {},
+      })}`,
+    )
+
+    const { output, stderr, exitCode } = await serve([
+      'discover',
+      'generate',
+      mod,
+      '--output',
+      outFile,
+    ])
+    expect(exitCode).toBeUndefined()
+    expect(output).toBe('')
+    expect(stderr).toContain(outFile)
+    const written = JSON.parse(fs.readFileSync(outFile, 'utf-8'))
+    expect(written.openapi).toBe('3.1.0')
+
+    fs.rmSync(dir, { recursive: true, force: true })
+  })
+
+  test('errors when module not found', async () => {
+    const { output, exitCode } = await serve([
+      'discover',
+      'generate',
+      '/tmp/nonexistent-mppx-module.mjs',
+    ])
+    expect(exitCode).toBe(1)
+    expect(output).toContain('MODULE_NOT_FOUND')
+  })
+
+  test('errors when module has no mppx or openapi export', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-generate-'))
+    const mod = path.join(dir, 'bad.mjs')
+    fs.writeFileSync(mod, 'export default { foo: "bar" }')
+
+    const { output, exitCode } = await serve(['discover', 'generate', mod])
+    expect(exitCode).toBe(1)
+    expect(output).toContain('INVALID_MODULE')
+
+    fs.rmSync(dir, { recursive: true, force: true })
+  })
+})
+
 describe('basic charge (examples/basic)', () => {
   test('happy path: makes payment and receives response', { timeout: 120_000 }, async () => {
     const { Actions } = await import('viem/tempo')