@misofm/api-client 0.1.1 → 0.1.2

package/README.md

@@ -3,9 +3,9 @@
 Typed client, schemas, and response contracts for the Miso API read layer.
 
 ```ts
-import { MisoApiClient } from "@misofm/api-client";
+import { createMisoApiClient } from "@misofm/api-client";
 
-const client = new MisoApiClient({ baseUrl: "https://api.testnet.miso.fm" });
+const client = createMisoApiClient({ baseUrl: "https://api.testnet.miso.fm" });
 ```
 
 The package is maintained in the [`misofm/api`](https://github.com/misofm/api)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misofm/api-client",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Typed client and response contract for the Miso API read layer. The one definition of what a Miso read returns.",
   "license": "Apache-2.0",
   "repository": {

package/src/index.ts

@@ -5,7 +5,7 @@
 // Miso read API.
 //
 // This package is what every Miso frontend reads through: the PWA, the CLI,
-// agents. It carries no chain code and no Sui dependency — a browser importing it
+// and third-party clients. It carries no chain code and no Sui dependency — a browser importing it
 // gets zod and a fetch wrapper, not a blockchain SDK.
 //
 //   import { createMisoApiClient } from "@misofm/api-client";
@@ -19,7 +19,3 @@ export type { CacheClass, CachePolicy } from "./cache.ts";
 
 export * as schemas from "./schemas.ts";
 export type * from "./types.ts";
-
-// Card checkout lives in miso-platform-service, not the read service, but it is
-// the same API to a caller — one package, one base URL, one error type.
-export * from "./checkout.ts";

package/src/schemas.ts

@@ -6,11 +6,11 @@
 //   · @misofm/api-client infers its types from it
 //   · miso-read-service generates its OpenAPI document from it
 //   · a contract test in that service parses every handler's real output through
-//     it, so a change in @misonetwork/sdk that these schemas don't describe fails CI
+//     it, so a change in @misofm/sdk/read that these schemas don't describe fails CI
 //     rather than reaching a client
 //
 // Schemas, not hand-written interfaces, precisely so that third clause is
-// possible. Agents, the CLI, and any future surface read the same OpenAPI.
+// possible. The CLI and any future client read the same OpenAPI.
 //
 // SCALARS: every u64/u128 is a DECIMAL STRING (`u64Schema`), never a number.
 // Prices, supply counts, and balances routinely exceed 2^53, and JSON has no
@@ -146,19 +146,28 @@ export const recordingCreditsSchema = z.object({
 
 /** Per-track credits for a release. Composition writing and recording
  * performance/production credits remain separate. */
-export const trackCreditsSchema = z.union([
-  z.object({
-    compositionCredits: z.array(creditSchema),
-    recordingCredits: recordingCreditsSchema,
-  }),
-  // Keep already-deployed recording-only responses usable while the read service
-  // rolls out the composition-credit projection.
-  recordingCreditsSchema.transform((recordingCredits) => ({
-    compositionCredits: [],
-    recordingCredits,
-  })),
+const completeTrackCreditsSchema = z.object({
+  compositionCredits: z.array(creditSchema),
+  recordingCredits: recordingCreditsSchema,
+});
+
+/** The HTTP wire accepts the complete shape and the deployed recording-only shape. */
+export const trackCreditsWireSchema = z.union([
+  completeTrackCreditsSchema,
+  recordingCreditsSchema,
 ]);
 
+/** Clients always receive the complete shape, including during the rollout. */
+export const trackCreditsSchema = trackCreditsWireSchema.transform((credits) =>
+  "recordingCredits" in credits
+    ? credits
+    : { compositionCredits: [], recordingCredits: credits },
+);
+
+/** Transform-free wire schema used when generating OpenAPI. */
+export const releaseTrackCreditsWireSchema = z.object({
+  tracks: z.record(suiIdSchema, trackCreditsWireSchema),
+});
 /** Per-track work credits for a release, keyed by recording id. */
 export const releaseTrackCreditsSchema = z.object({
   tracks: z.record(suiIdSchema, trackCreditsSchema),

package/src/checkout.ts

@@ -1,146 +0,0 @@
-// Copyright (c) Miso Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-//
-// The card-checkout contract (Stripe on-ramp for records). Served by
-// miso-platform-service under `/platform/checkout`, not by the read service — it
-// is a WRITE surface with its own Durable Object payment gate — but it lives in
-// this package so an app has one API dependency rather than two.
-//
-// Lifted from miso-app's `lib/checkout-client.ts`, which was hand-written against
-// the backend and had no way to notice the backend changing.
-//
-//   quote → sign → session → redirect to Stripe → poll the receipt
-
-import { z } from "zod";
-import { MisoApiError } from "./client.ts";
-
-export const checkoutQuoteSchema = z.object({
-  /** The signed payload the buyer signs to prove intent. */
-  payload: z.string(),
-  nonce: z.string(),
-  /** What the card will actually be charged, in USD cents (price + card fee). */
-  cardAmountCents: z.number().int(),
-  expiresAt: z.string(),
-  priceDisplay: z.string(),
-});
-
-export const checkoutSessionSchema = z.object({
-  /** Stripe Checkout URL to redirect to. */
-  url: z.string().url(),
-  orderId: z.string(),
-});
-
-export const orderStateSchema = z.enum([
-  "awaiting_payment",
-  "paid",
-  "fulfilling",
-  "under_review",
-  "fulfilled",
-  "fulfill_failed",
-  "refund_pending",
-  "refunded",
-  "expired",
-]);
-
-export const receiptLineItemSchema = z.object({
-  description: z.string(),
-  amountCents: z.number().int(),
-  /** ISO-4217, lowercase (always "usd"). */
-  currency: z.string(),
-  quantity: z.number().int(),
-});
-
-export const orderReceiptSchema = z.object({
-  state: orderStateSchema,
-  /** The Sui address the record is/was delivered to. */
-  buyerAddress: z.string(),
-  lineItems: z.array(receiptLineItemSchema),
-  /** The minted record's object id once fulfilled — the target of "Mix it now". */
-  recordObjectId: z.string().optional(),
-  txDigest: z.string().optional(),
-  network: z.enum(["testnet", "mainnet"]),
-  failureReason: z.string().optional(),
-});
-
-export type CheckoutQuote = z.infer<typeof checkoutQuoteSchema>;
-export type CheckoutSession = z.infer<typeof checkoutSessionSchema>;
-export type OrderState = z.infer<typeof orderStateSchema>;
-export type ReceiptLineItem = z.infer<typeof receiptLineItemSchema>;
-export type OrderReceipt = z.infer<typeof orderReceiptSchema>;
-
-/**
- * Terminal "you can't see this": the order uuid + session_id capability pair did
- * not resolve — unknown order, wrong or expired session, or a malformed link. The
- * API returns an identical 404 for all of these so nothing leaks about whether
- * the order exists, which means the client can't tell them apart either.
- *
- * **Stop polling on this.** Any other non-2xx is transient and safe to retry.
- */
-export class CheckoutNotFoundError extends MisoApiError {
-  constructor(message: string) {
-    super(404, "not_found", message);
-    this.name = "CheckoutNotFoundError";
-  }
-}
-
-export interface CheckoutClientOptions {
-  baseUrl: string;
-  fetch?: typeof globalThis.fetch;
-  /** Where the platform service is mounted on `baseUrl`. */
-  prefix?: string;
-}
-
-export function createCheckoutClient(options: CheckoutClientOptions) {
-  const base = options.baseUrl.replace(/\/$/, "");
-  const prefix = options.prefix ?? "/platform/checkout";
-  const doFetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-
-  async function parseError(res: Response): Promise<MisoApiError> {
-    const body = (await res.json().catch(() => null)) as { error?: string | { message?: string } } | null;
-    const raw = body?.error;
-    const message = typeof raw === "string" ? raw : (raw?.message ?? `Request failed (${res.status})`);
-    return new MisoApiError(res.status, "checkout_error", message);
-  }
-
-  async function post<T>(schema: z.ZodType<T>, path: string, body: unknown): Promise<T> {
-    const res = await doFetch(`${base}${prefix}${path}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) throw await parseError(res);
-    return schema.parse(await res.json());
-  }
-
-  return {
-    /** Price + signed-payload quote for a drop, for a given recipient. */
-    getQuote: (dropId: string, recipient: string): Promise<CheckoutQuote> =>
-      post(checkoutQuoteSchema, "/quote", { dropId, recipient }),
-
-    /** Verify the signature + Enoki identity, then open a Stripe session. */
-    createSession: (params: {
-      payload: string;
-      signature: string;
-      address: string;
-      nonce: string;
-      jwt: string;
-      recordName?: string;
-    }): Promise<CheckoutSession> => post(checkoutSessionSchema, "/session", params),
-
-    /**
-     * The buyer-scoped receipt for the post-purchase page. Requires the order
-     * uuid AND the Stripe session id from the success redirect — a capability
-     * pair, not an id lookup. A 404/400 throws {@link CheckoutNotFoundError}.
-     */
-    getReceipt: async (orderId: string, sessionId: string): Promise<OrderReceipt> => {
-      const res = await doFetch(
-        `${base}${prefix}/orders/${orderId}/receipt?session_id=${encodeURIComponent(sessionId)}`,
-      );
-      if (res.status === 404 || res.status === 400) throw new CheckoutNotFoundError((await parseError(res)).message);
-      if (!res.ok) throw await parseError(res);
-      return orderReceiptSchema.parse(await res.json());
-    },
-  };
-}
-
-export type CheckoutClient = ReturnType<typeof createCheckoutClient>;