tapimo 0.0.0 → 0.0.2

package/src/Assets.ts

@@ -0,0 +1,58 @@
+/**
+ * Binary asset store for static API assets (e.g. token logos), keyed by the
+ * loader layout `<chainId>/<path>`. Token icons are content-addressed by address
+ * (`4217/icons/0x…`, no extension); the stored content-type carries the format.
+ * Shared by the main API ({@link App.create}'s `assets`, read) and the admin app
+ * (`Admin.create`'s `assets`, read + write).
+ */
+
+/** A static asset: its bytes plus content type. */
+export type Asset = {
+  /** Asset bytes. */
+  body: ArrayBuffer
+  /** MIME type to serve the asset with. */
+  contentType: string
+}
+
+/** A binary asset store keyed by `<chainId>/<path>`. */
+export type Assets = {
+  /** Reads an asset by `key`, or `undefined` when absent. */
+  get(key: string): Promise<Asset | undefined>
+  /** Stores an asset at `key`, replacing any existing object. Omit for read-only stores. */
+  put?: ((key: string, asset: Asset) => Promise<void>) | undefined
+}
+
+/** Backs {@link Assets} with a Cloudflare R2 bucket. */
+export function cloudflareR2(bucket: cloudflareR2.Bucket): Assets {
+  return {
+    async get(key) {
+      const object = await bucket.get(key)
+      if (!object) return undefined
+      return {
+        body: await object.arrayBuffer(),
+        contentType: object.httpMetadata?.contentType ?? 'application/octet-stream',
+      }
+    },
+    put: (key, { body, contentType }) =>
+      bucket.put(key, body, { httpMetadata: { contentType } }).then(() => undefined),
+  }
+}
+
+export declare namespace cloudflareR2 {
+  /** Minimal Cloudflare R2 bucket shape used by this adapter. */
+  type Bucket = {
+    /** Gets an object, or `null` when absent. */
+    get(key: string): Promise<{
+      /** Reads the object body as bytes. */
+      arrayBuffer(): Promise<ArrayBuffer>
+      /** HTTP metadata stored with the object. */
+      httpMetadata?: { contentType?: string | undefined } | undefined
+    } | null>
+    /** Writes an object. */
+    put(
+      key: string,
+      value: ArrayBuffer,
+      options?: { httpMetadata?: { contentType?: string | undefined } | undefined },
+    ): Promise<unknown>
+  }
+}

package/src/Auth.ts

@@ -0,0 +1 @@
+export { middleware } from './internal/Auth.js'

package/src/Cli.test.ts

@@ -0,0 +1,81 @@
+import { Cli } from 'cadent'
+import * as TestApp from '../test/App.js'
+import * as Runtime from '../test/runtime.js'
+
+const apiUrl = 'https://api.tempo-api.test'
+
+describe('from', () => {
+  test('creates a Tempo API incur CLI', async () => {
+    const fetch = mockHostedApi()
+
+    try {
+      const cli = Cli.from(apiUrl, { version: '1.2.3' })
+      await serve(cli, ['--help'])
+
+      expect(cli.name).toMatchInlineSnapshot(`"tempo-api"`)
+      expect(cli.description).toMatchInlineSnapshot(`"Tempo API CLI"`)
+    } finally {
+      fetch.mockRestore()
+    }
+  })
+
+  test('serves the hosted Tempo API command', async () => {
+    // Verified tokens are KV/store-backed (no bundled fallback), so seed the
+    // store for the default chain to exercise the `--verified` listing.
+    const fetch = mockHostedApi(
+      TestApp.create({ verifiedTokens: { store: TestApp.verifiedStore(Runtime.get().chainId) } }),
+    )
+
+    try {
+      const cli = Cli.from(apiUrl)
+      // `/v1/tokens?verified=true` now serves the curated verified list through
+      // the standard listing endpoint, so the CLI surfaces the filter as a
+      // `--verified` flag on the `v1 tokens get` command instead of routing
+      // through a separate `tokens verified` subcommand. Data routes are mounted
+      // under the `/v1` prefix, which incur namespaces as a top-level `v1` group.
+      const output = await serve(cli, [
+        'v1',
+        'tokens',
+        'get',
+        '--verified',
+        'true',
+        '--format',
+        'json',
+      ])
+      const body = JSON.parse(output)
+
+      expect(body.nextCursor).toBeNull()
+      expect(body.data.length).toBeGreaterThan(0)
+      expect(body.data.every((token: { verified: boolean }) => token.verified === true)).toBe(true)
+    } finally {
+      fetch.mockRestore()
+    }
+  })
+})
+
+function mockHostedApi(app = TestApp.create()) {
+  const fetch = globalThis.fetch
+  return vi.spyOn(globalThis, 'fetch').mockImplementation(async (input, init) => {
+    const request = input instanceof Request ? input : new Request(input, init)
+    const url = new URL(request.url)
+    if (url.origin !== apiUrl) return fetch(input, init)
+
+    // `Cli.from(url)` uses incur's hosted request source, which ultimately
+    // calls global fetch. Route the fake hosted origin into the local test app
+    // so the test covers the URL-backed path without real network I/O.
+    return app.fetch(new Request(url, request))
+  })
+}
+
+async function serve(cli: ReturnType<typeof Cli.from>, argv: string[]) {
+  const output: string[] = []
+  await cli.serve(argv, {
+    exit(code) {
+      throw new Error(`unexpected exit ${code}: ${output.join('')}`)
+    },
+    stdout(value) {
+      output.push(value)
+    },
+  })
+  return output.join('')
+}

package/src/Cli.ts

@@ -0,0 +1,38 @@
+import { Cli as incur_Cli, Fetch, type Openapi } from 'incur'
+
+/** Creates an incur CLI backed by a hosted Tempo API. */
+export function from(url: string | URL, options: from.Options = {}) {
+  const {
+    description = 'Tempo API CLI',
+    name = 'tempo-api',
+    openapi = 'openapi.json',
+    request,
+    version = '0.0.0',
+  } = options
+
+  return incur_Cli.create(name, {
+    description,
+    fetch: Fetch.fromRequest(url, request),
+    openapi,
+    openapiConfig: options.openapiConfig ?? { mode: 'namespace' },
+    version,
+  })
+}
+
+export declare namespace from {
+  /** Options for creating a Tempo API CLI from a hosted API. */
+  type Options = {
+    /** CLI description. */
+    description?: string | undefined
+    /** CLI name. */
+    name?: string | undefined
+    /** OpenAPI document source. Relative paths resolve from the API URL. */
+    openapi?: Openapi.OpenAPISource | undefined
+    /** OpenAPI command generation configuration. Defaults to namespace mode. */
+    openapiConfig?: Openapi.Config | undefined
+    /** Request options applied to API calls. */
+    request?: Fetch.fromRequest.Options | undefined
+    /** CLI version. */
+    version?: string | undefined
+  }
+}