@doany-ai/sdk 0.2.4 → 0.2.6

package/dist/client.js

@@ -186,6 +186,24 @@ export function createClient(config) {
         integrations: createIntegrationsModule(serviceRoleAxiosClient, appId),
         sso: createSsoModule(serviceRoleAxiosClient, appId),
         connectors: createConnectorsModule(serviceRoleAxiosClient, appId),
+        // Reading a checkout or a plan with server credentials, which is what a
+        // fulfilment function is doing and what the platform requires of it:
+        // payments resolves test-vs-live from the address the site is served
+        // from, and the browser Origin a function carries is honoured only for a
+        // service-role caller. Through the ordinary client that check cannot pass,
+        // so the call fails no matter what the function forwards.
+        //
+        // The two reads only, and enforced here rather than by the type alone:
+        // opening a checkout is a decision that belongs to the browser that is
+        // actually there, and a function naming its own mode could charge a real
+        // card from a preview.
+        payments: (() => {
+            const full = createPaymentsModule(serviceRoleAxiosClient, appId);
+            return {
+                getCheckoutSession: full.getCheckoutSession.bind(full),
+                getSubscription: full.getSubscription.bind(full),
+            };
+        })(),
         functions: createFunctionsModule(serviceRoleFunctionsAxiosClient, appId, {
             getAuthHeaders: () => {
                 const headers = {};
@@ -357,6 +375,7 @@ export function createClientFromRequest(request) {
     const functionsVersion = request.headers.get("Doany-Functions-Version");
     const stateHeader = request.headers.get("Doany-State");
     const dataEnvHeader = request.headers.get("X-Data-Env");
+    const originHeader = request.headers.get("X-Doany-Origin");
     if (!appId) {
         throw new Error("Doany-App-Id header is required, but is was not found on the request");
     }
@@ -394,6 +413,33 @@ export function createClientFromRequest(request) {
     if (dataEnvHeader === "dev" || dataEnvHeader === "prod") {
         additionalHeaders["X-Data-Env"] = dataEnvHeader;
     }
+    // The browser Origin of the request that reached the backend, forwarded to us
+    // by the function proxy. Payments resolves test-vs-live from the address the
+    // site is served from, and a function's own call has no Origin at all — so
+    // without this every `getCheckoutSession` from inside a fulfilment function
+    // fails with "Origin header is required for payments", which is the shape the
+    // payments guide documents.
+    //
+    // Reduced to an origin rather than shape-matched. The proxy falls back to
+    // Referer when a request carries no Origin — a same-origin GET or HEAD, which
+    // is exactly what `functions.fetch` sends — and a Referer carries the path:
+    // `https://shop.example/thanks?session_id=…`. Matching "origin-shaped" threw
+    // every one of those away and left the function right back where it started.
+    //
+    // Parsed, not trusted: the value only ever becomes a LOOKUP against this
+    // app's own hostnames, and the backend honours it solely for a service-role
+    // caller. `URL` throws on anything that is not a URL, which is the check.
+    if (originHeader) {
+        try {
+            const { origin } = new URL(originHeader);
+            if (origin !== "null") {
+                additionalHeaders["X-Doany-Origin"] = origin;
+            }
+        }
+        catch (_a) {
+            // Not a URL. Forwarding it would only make the failure harder to read.
+        }
+    }
     return createClient({
         serverUrl: serverUrlHeader || "https://api.doany.ai",
         appId,

package/dist/client.types.d.ts

@@ -142,6 +142,18 @@ export interface DoanyClient {
         functions: FunctionsModule;
         /** {@link IntegrationsModule | Integrations module} with elevated permissions. */
         integrations: IntegrationsModule;
+        /**
+         * Reading a checkout session or a subscription with server credentials.
+         *
+         * A fulfilment function must use THIS one, not `doany.payments`: the
+         * platform honours a function's forwarded browser Origin only for a
+         * service-role caller, so the ordinary client cannot resolve a mode and
+         * the read fails whatever the function forwards.
+         *
+         * Only the reads are here. There is no service-role checkout — opening one
+         * is a decision that belongs to the browser that is actually there.
+         */
+        payments: Pick<PaymentsModule, "getCheckoutSession" | "getSubscription">;
         /** {@link SsoModule | SSO module} for generating SSO tokens.
          * @internal
          */

package/dist/modules/payments.types.d.ts

@@ -113,6 +113,19 @@ export type SubscriptionState = {
     interval: string | null;
     amount: number | null;
     currency: string | null;
+    /**
+     * WHICH plan they are on — the `Product` record id, not what it costs.
+     *
+     * A plan switch happens on Stripe's billing portal and never returns through
+     * the success page, so this is the only way an app learns the new tier.
+     *
+     * Do not stand `amount` in for it: prices change, and two tiers can charge
+     * the same in different currencies or billing periods, so an app gating
+     * features on a number grants the wrong ones.
+     *
+     * `null` for a subscription older than durable prices.
+     */
+    product_id: string | null;
     metadata: Record<string, string>;
 };
 export type BillingPortalParams = {
@@ -158,6 +171,18 @@ export type CheckoutSession = {
         name: string | null;
         quantity: number | null;
         amount_total: number | null;
+        /**
+         * The `Product` record this line was sold from — **gate on this, never on
+         * `name`**.
+         *
+         * A product's name is founder-editable and changes without warning, so an
+         * app granting access by comparing names stops matching the moment one is
+         * renamed. This id is stable for the life of the record.
+         *
+         * `null` for an order placed before durable prices, or one whose Stripe
+         * product id had to be hashed for length.
+         */
+        product_id: string | null;
     }>;
     metadata: Record<string, string>;
     /**

package/dist/utils/axios-client.js

@@ -123,6 +123,18 @@ export function createAxiosClient({ baseURL, headers = {}, token, interceptRespo
             Accept: "application/json",
             ...headers,
         },
+        // Where there is no XHR — a backend function on Cloudflare Workers, Deno,
+        // Node — axios falls back to its fetch adapter, which builds a `Request`
+        // and hands it to `fetch`. A `Request` defaults to `cache: "default"`, and
+        // workerd accepts only "no-store", so it throws `Unsupported cache mode:
+        // default` before anything reaches the network. Measured on a live app:
+        // every `asServiceRole.entities.*` call from inside a backend function
+        // failed this way, which is exactly the fulfilment path a payment is told
+        // to use — an anonymous checkout took the money and wrote no order.
+        //
+        // Browsers keep the XHR adapter and ignore this entirely. Where it does
+        // apply, not caching is the correct behaviour for an API call anyway.
+        fetchOptions: { cache: "no-store" },
     });
     // Add token to requests if available
     if (token) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doany-ai/sdk",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "JavaScript SDK for the doany app platform (API-compatible fork of @base44/sdk)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",