@doany-ai/sdk 0.2.5 → 0.2.7

package/dist/client.js

@@ -3,7 +3,7 @@ import { createEntitiesModule } from "./modules/entities.js";
 import { createIntegrationsModule } from "./modules/integrations.js";
 import { createAuthModule } from "./modules/auth.js";
 import { createSsoModule } from "./modules/sso.js";
-import { createConnectorsModule, createUserConnectorsModule, } from "./modules/connectors.js";
+import { confirmAppUserConnection, createConnectorsModule, createUserConnectorsModule, } from "./modules/connectors.js";
 import { getAccessToken } from "./utils/auth-utils.js";
 import { createFunctionsModule } from "./modules/functions.js";
 import { createPaymentsModule } from "./modules/payments.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 = {};
@@ -213,6 +231,14 @@ export function createClient(config) {
         },
     };
     // If authentication is required, verify token and redirect to login if needed
+    // An app user coming back from a connector sign-in carries a one-time code
+    // (doany_connector, doany_connector_code). Confirm it with THIS user's
+    // session and drop it from the URL — app code never has to do this, and a
+    // forwarded link cannot attach a stranger's account because the confirm
+    // rides the session, not the code alone.
+    if (typeof window !== "undefined" && window.location) {
+        void finishPendingConnectorSignIn(axiosClient, appId);
+    }
     if (requiresAuth && typeof window !== "undefined") {
         // We perform this check asynchronously to not block client creation
         setTimeout(async () => {
@@ -357,6 +383,8 @@ 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");
+    const runIdHeader = request.headers.get("X-Run-Id");
     if (!appId) {
         throw new Error("Doany-App-Id header is required, but is was not found on the request");
     }
@@ -394,6 +422,41 @@ 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.
+        }
+    }
+    // The agent run this work belongs to. A backend function called from a
+    // run and one an app calls on its own are the same request shape, and this
+    // header is the only thing that tells them apart — the platform bills the
+    // run for the first and the app for the second. Dropped here, an agent's
+    // connector calls were attributed to the app.
+    if (runIdHeader) {
+        additionalHeaders["X-Run-Id"] = runIdHeader.slice(0, 128);
+    }
     return createClient({
         serverUrl: serverUrlHeader || "https://api.doany.ai",
         appId,
@@ -403,3 +466,40 @@ export function createClientFromRequest(request) {
         headers: additionalHeaders,
     });
 }
+const CONNECTOR_RETURN_PARAMS = ["doany_connector", "doany_connector_code", "doany_connector_status"];
+async function finishPendingConnectorSignIn(axios, appId) {
+    var _a, _b;
+    let params;
+    try {
+        params = new URLSearchParams(window.location.search);
+    }
+    catch (_c) {
+        return;
+    }
+    const connectorId = params.get("doany_connector");
+    const code = params.get("doany_connector_code");
+    if (!connectorId || !code)
+        return;
+    try {
+        await confirmAppUserConnection(axios, appId, connectorId, code);
+    }
+    catch (error) {
+        console.error("Could not finish the connector sign-in:", error);
+        // The code is one-time, so it stays in the URL while the failure may
+        // pass — no network, a 5xx, or a sign-in the app has not restored yet
+        // (401): a reload, or the app's own login, retries the confirmation.
+        // A definite rejection (spent, wrong or expired code) is cleared like a
+        // success, because retrying cannot help.
+        // The client's interceptor turns Axios failures into DoanyError, which
+        // carries the HTTP code as `status`; a raw Axios error keeps it under
+        // `response.status`.
+        const status = (_a = error === null || error === void 0 ? void 0 : error.status) !== null && _a !== void 0 ? _a : (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.status;
+        const definite = typeof status === "number" && status >= 400 && status < 500 && ![401, 408, 429].includes(status);
+        if (!definite)
+            return;
+    }
+    for (const name of CONNECTOR_RETURN_PARAMS)
+        params.delete(name);
+    const query = params.toString();
+    window.history.replaceState({}, document.title, `${window.location.pathname}${query ? `?${query}` : ""}${window.location.hash}`);
+}

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/index.d.ts

@@ -13,6 +13,6 @@ export type { AiGatewayModule, AiGatewayConnection, } from "./modules/ai-gateway
 export type { AppLogsModule } from "./modules/app-logs.types.js";
 export type { PaymentsModule, CheckoutLineItem, CreateCheckoutParams, CreateCheckoutResult, CreateEmbeddedCheckoutResult, CheckoutSession, SubscriptionState, BillingPortalParams, } from "./modules/payments.types.js";
 export type { SsoModule, SsoAccessTokenResponse } from "./modules/sso.types.js";
-export type { ConnectorsModule, UserConnectorsModule, } from "./modules/connectors.types.js";
+export type { ConnectorsModule, UserConnectorsModule, ConnectorApiRequest, ConnectorApiResponse, ConnectorProxyRawResponse, } from "./modules/connectors.types.js";
 export type { CustomIntegrationsModule, CustomIntegrationCallParams, CustomIntegrationCallResponse, } from "./modules/custom-integrations.types.js";
 export type { GetAccessTokenOptions, SaveAccessTokenOptions, RemoveAccessTokenOptions, GetLoginUrlOptions, } from "./utils/auth-utils.types.js";

package/dist/modules/connectors.d.ts

@@ -1,5 +1,12 @@
 import { AxiosInstance } from "axios";
 import { ConnectorsModule, UserConnectorsModule } from "./connectors.types.js";
+/**
+ * Finishes an app-user connection with the one-time code the platform put in
+ * the return URL. Called by the client on page load, never by app code: the
+ * confirm must ride the same user's session that started the sign-in.
+ * @internal
+ */
+export declare function confirmAppUserConnection(axios: AxiosInstance, appId: string, connectorId: string, code: string): Promise<void>;
 /**
  * Creates the Connectors module for the Doany SDK.
  *

package/dist/modules/connectors.js

@@ -1,3 +1,60 @@
+const CONNECTOR_API_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
+function assertNonEmptyString(value, label) {
+    if (!value || typeof value !== "string") {
+        throw new Error(`${label} is required and must be a string`);
+    }
+}
+/**
+ * One proxied call, exactly as @base44/sdk does it: validate the request,
+ * post the raw shape, map the raw (snake_case) answer to the typed one.
+ */
+async function proxyCall(axios, url, request) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    if (!request || typeof request !== "object") {
+        throw new Error("Request is required and must be an object");
+    }
+    assertNonEmptyString(request.path, "Request path");
+    const method = (_a = request.method) !== null && _a !== void 0 ? _a : "GET";
+    if (!CONNECTOR_API_METHODS.has(method)) {
+        throw new Error("Request method must be one of GET, POST, PUT, PATCH, DELETE, or HEAD");
+    }
+    const response = await axios.post(url, {
+        method,
+        // Omitted when unset so the proxy applies the connector's default host.
+        ...(request.host == null ? {} : { host: request.host }),
+        path: request.path,
+        query: (_b = request.query) !== null && _b !== void 0 ? _b : {},
+        headers: (_c = request.headers) !== null && _c !== void 0 ? _c : {},
+        body: (_d = request.body) !== null && _d !== void 0 ? _d : null,
+    });
+    const data = response;
+    return {
+        success: data.success,
+        phase: data.phase,
+        status: (_e = data.status_code) !== null && _e !== void 0 ? _e : null,
+        data: data.data,
+        dataBase64: (_f = data.data_base64) !== null && _f !== void 0 ? _f : null,
+        contentType: (_g = data.content_type) !== null && _g !== void 0 ? _g : null,
+        headers: (_h = data.headers) !== null && _h !== void 0 ? _h : {},
+        creditsCharged: (_j = data.credits_charged) !== null && _j !== void 0 ? _j : 0,
+        // A 200 envelope can still carry a failure (`sent_unconfirmed`, or the
+        // provider's own error); without these the caller knows a write may
+        // have happened but not why the answer is missing.
+        ...(data.error == null ? {} : { error: data.error }),
+        ...(data.error_message == null ? {} : { errorMessage: data.error_message }),
+    };
+}
+/**
+ * Finishes an app-user connection with the one-time code the platform put in
+ * the return URL. Called by the client on page load, never by app code: the
+ * confirm must ride the same user's session that started the sign-in.
+ * @internal
+ */
+export async function confirmAppUserConnection(axios, appId, connectorId, code) {
+    assertNonEmptyString(connectorId, "Connector ID");
+    assertNonEmptyString(code, "Confirmation code");
+    await axios.post(`/apps/${appId}/app-user-auth/connectors/${encodeURIComponent(connectorId)}/confirm`, { code });
+}
 /**
  * Creates the Connectors module for the Doany SDK.
  *
@@ -8,6 +65,16 @@
  */
 export function createConnectorsModule(axios, appId) {
     return {
+        async callApi(integrationType, request) {
+            assertNonEmptyString(integrationType, "Integration type");
+            // Encoded so a runtime-built identifier can only ever select a
+            // connector, never re-target another route under this token.
+            return proxyCall(axios, `/apps/${appId}/connectors/${encodeURIComponent(integrationType)}/call`, request);
+        },
+        async callCurrentAppUserApi(integrationType, request) {
+            assertNonEmptyString(integrationType, "Integration type");
+            return proxyCall(axios, `/apps/${appId}/app-user-connectors/${encodeURIComponent(integrationType)}/call`, request);
+        },
         /**
          * Retrieve an OAuth access token for a specific external integration type.
          * @deprecated Use getConnection(integrationType) and use the returned accessToken (and connectionConfig when needed) instead.
@@ -81,18 +148,14 @@ export function createConnectorsModule(axios, appId) {
 export function createUserConnectorsModule(axios, appId) {
     return {
         async connectAppUser(connectorId) {
-            if (!connectorId || typeof connectorId !== "string") {
-                throw new Error("Connector ID is required and must be a string");
-            }
-            const response = await axios.post(`/apps/${appId}/app-user-auth/connectors/${connectorId}/initiate`);
+            assertNonEmptyString(connectorId, "Connector ID");
+            const response = await axios.post(`/apps/${appId}/app-user-auth/connectors/${encodeURIComponent(connectorId)}/initiate`);
             const data = response;
             return data.redirect_url;
         },
         async disconnectAppUser(connectorId) {
-            if (!connectorId || typeof connectorId !== "string") {
-                throw new Error("Connector ID is required and must be a string");
-            }
-            await axios.delete(`/apps/${appId}/app-user-auth/connectors/${connectorId}`);
+            assertNonEmptyString(connectorId, "Connector ID");
+            await axios.delete(`/apps/${appId}/app-user-auth/connectors/${encodeURIComponent(connectorId)}`);
         },
     };
 }

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

@@ -41,6 +41,65 @@ export interface AppUserConnectorConnectionResponse {
     /** Key-value configuration for the connection, or `null` if the connector does not provide one. */
     connectionConfig: Record<string, string> | null;
 }
+/**
+ * A request proxied to the external service on the app's behalf. The
+ * platform injects the credential; the app never sees a token.
+ */
+export interface ConnectorApiRequest {
+    /** HTTP method. Defaults to `GET`. */
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
+    /** Path relative to the provider's API root. Must start with `/`. */
+    path: string;
+    /** Provider host to call; defaults to the connector's primary API host. Must be one of the connector's allowed hosts. */
+    host?: string;
+    /** Query parameters. */
+    query?: Record<string, string>;
+    /** Extra request headers. `Authorization` is ignored — the platform sets it. */
+    headers?: Record<string, string>;
+    /** JSON body. */
+    body?: unknown;
+}
+/**
+ * What a proxied call produced. HTTP 200 from the platform means only that
+ * the proxy worked; read `success`, `phase` and `status` for what the
+ * provider did.
+ */
+export interface ConnectorApiResponse<T = unknown> {
+    /** The provider answered 2xx. */
+    success: boolean;
+    /**
+     * `not_sent` — the request never left the platform (safe to retry).
+     * `responded` — the provider answered; see `status`.
+     * `sent_unconfirmed` — sent, but no answer came back; a write may have happened. Never auto-retry a write on this.
+     */
+    phase: "not_sent" | "responded" | "sent_unconfirmed";
+    /** The provider's HTTP status, or `null` when there was no response. */
+    status: number | null;
+    /** The provider's JSON body, when it sent one. */
+    data: T | null;
+    /** The provider's body as base64 when it was binary. */
+    dataBase64: string | null;
+    contentType: string | null;
+    headers: Record<string, string>;
+    /** Credits charged for this call. */
+    creditsCharged: number;
+    /** Set when `phase` is not `responded`. */
+    error?: string;
+    errorMessage?: string;
+}
+/** The proxy's raw answer on the wire (snake_case); {@link ConnectorApiResponse} is its typed form. */
+export interface ConnectorProxyRawResponse<T = unknown> {
+    success: boolean;
+    phase: "not_sent" | "responded" | "sent_unconfirmed";
+    status_code?: number | null;
+    data: T | null;
+    data_base64?: string | null;
+    content_type?: string | null;
+    headers?: Record<string, string>;
+    credits_charged?: number;
+    error?: string;
+    error_message?: string;
+}
 /**
  * Connectors module for managing OAuth tokens for external services.
  *
@@ -131,6 +190,32 @@ export interface AppUserConnectorConnectionResponse {
  * If you're working in a TypeScript project, you can generate types from your app's connector configurations to get autocomplete on integration type names when calling {@link getConnection}. See the [Dynamic Types](/developers/references/sdk/getting-started/dynamic-types) guide to get started.
  */
 export interface ConnectorsModule {
+    /**
+     * Calls the external service through the platform with the app's shared connection.
+     *
+     * This is the only way a backend function reaches a connector on doany: the platform injects the credential and forwards the request. The token methods below answer 403.
+     *
+     * @param integrationType - The connector's integration type, e.g. `'gmail'`.
+     * @param request - Method, path (relative to the provider's API root), query, headers and body.
+     * @returns The provider's answer wrapped in `success` / `phase` / `status`.
+     *
+     * @example
+     * ```typescript
+     * const res = await doany.asServiceRole.connectors.callApi('gmail', {
+     *   method: 'POST',
+     *   path: '/gmail/v1/users/me/messages/send',
+     *   body: { raw },
+     * });
+     * if (!res.success) { /* res.status is the provider's code, res.data its body *\/ }
+     * ```
+     */
+    callApi<T = unknown>(integrationType: ConnectorIntegrationType, request: ConnectorApiRequest): Promise<ConnectorApiResponse<T>>;
+    /**
+     * Calls the external service as the signed-in app user, through their own connection.
+     *
+     * Only works from a backend function the user triggered (the platform needs their identity). Same envelope as {@linkcode callApi}.
+     */
+    callCurrentAppUserApi<T = unknown>(integrationType: ConnectorIntegrationType, request: ConnectorApiRequest): Promise<ConnectorApiResponse<T>>;
     /**
      * Retrieves an OAuth access token for a specific [external integration type](#available-connectors).
      *

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/package.json

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