@muxoai/sdk 1.3.0 → 1.4.2

package/dist/provisioning-managed.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Muxo-managed stand-ins for Stripe v2 Provisioning objects, returned when no Stripe key is
+ * configured so both the Node server and the edge worker answer with the same shapes.
+ */
+export type ManagedProvisioningObject = Record<string, unknown> & {
+    source: "muxo_managed";
+};
+export type ManagedResourceAction = "remove" | "unlink" | "rotate_credentials" | "submit_information";
+export declare function managedProviderConnectionList(): ManagedProvisioningObject;
+export declare function managedProviderConnectionUnlink(id: string): ManagedProvisioningObject;
+export declare function managedProviderConnectionRequest(params: {
+    id?: string;
+    provider?: string;
+    requestStatus?: string;
+}): ManagedProvisioningObject;
+export declare function managedResource(params: {
+    id?: string;
+    provider?: string;
+    serviceRef?: string;
+    name?: string | null;
+    environment?: string;
+    catalog?: string;
+    status?: string;
+}): ManagedProvisioningObject;
+export declare function managedResourceAction(id: string, action: ManagedResourceAction): ManagedProvisioningObject;
+export declare function managedConnectedAccount(params: {
+    id?: string;
+    contactEmail?: string;
+    displayName?: string;
+    country?: string;
+    entityType?: "individual" | "company";
+}): ManagedProvisioningObject;
+export declare function managedConnectedAccountLink(account: string): ManagedProvisioningObject;
+export declare function managedConnectedAccountSession(params: {
+    account: string;
+    enableAccountManagement?: boolean;
+    enableNotificationBanner?: boolean;
+}): ManagedProvisioningObject;
+export declare function managedPaymentMethodRequest(params: {
+    publicWebUrl: string;
+    livemode: boolean;
+}): ManagedProvisioningObject;
+export declare const DEFAULT_PROVISIONING_EVENT_TYPES: string[];
+export declare function managedEventDestination(params: {
+    url: string;
+    name?: string;
+    events?: string[];
+}): ManagedProvisioningObject;
+/** What Muxo does with a Stripe v2 thin event, keyed by event type. */
+export declare function provisioningEventAction(eventType: string, hasRelatedObject: boolean): string;

package/dist/provisioning-managed.js

@@ -0,0 +1,155 @@
+/**
+ * Muxo-managed stand-ins for Stripe v2 Provisioning objects, returned when no Stripe key is
+ * configured so both the Node server and the edge worker answer with the same shapes.
+ */
+function managedId(prefix) {
+    const bytes = new Uint8Array(8);
+    crypto.getRandomValues(bytes);
+    return `${prefix}_muxo_${Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("")}`;
+}
+export function managedProviderConnectionList() {
+    return {
+        object: "v2.list",
+        data: [],
+        next_page_url: null,
+        previous_page_url: null,
+        source: "muxo_managed",
+    };
+}
+export function managedProviderConnectionUnlink(id) {
+    return {
+        id,
+        object: "v2.provisioning.provider_connection",
+        provider: null,
+        status: "unlinked",
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+export function managedProviderConnectionRequest(params) {
+    return {
+        id: params.id || managedId("pcr"),
+        object: "v2.provisioning.provider_connection_request",
+        provider: params.provider || null,
+        request_status: params.requestStatus || "requested",
+        redirect_url: null,
+        needs_information_schema: null,
+        provider_connection: null,
+        created: new Date().toISOString(),
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+export function managedResource(params) {
+    return {
+        id: params.id || managedId("res"),
+        object: "v2.provisioning.resource",
+        provider: params.provider || null,
+        service_ref: params.serviceRef || null,
+        name: params.name ?? null,
+        environment: params.environment === "dev" ? "dev" : "prod",
+        catalog: params.catalog || "prod",
+        status: params.status || "pending",
+        pending_action: null,
+        created: new Date().toISOString(),
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+const ACTION_STATUS = {
+    remove: "removed",
+    unlink: "unlinked",
+    rotate_credentials: "active",
+    submit_information: "provisioning",
+};
+export function managedResourceAction(id, action) {
+    return {
+        ...managedResource({ id, status: ACTION_STATUS[action] }),
+        action,
+        ...(action === "rotate_credentials" ? { credentials_rotated_at: new Date().toISOString() } : {}),
+    };
+}
+function hexOf(text, length) {
+    return Array.from(new TextEncoder().encode(text))
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("")
+        .slice(0, length);
+}
+export function managedConnectedAccount(params) {
+    return {
+        id: params.id || `acct_v2_${hexOf(`${params.contactEmail || ""}:${params.displayName || ""}`, 12)}`,
+        object: "v2.core.account",
+        ...(params.contactEmail ? { contact_email: params.contactEmail } : {}),
+        display_name: params.displayName || "Muxo Tenant Account",
+        identity: { country: params.country || "US", entity_type: params.entityType || "company" },
+        configuration: { developer: { capabilities: { projects: { requested: true, status: "active" } } } },
+        requirements: { currently_due: [], eventually_due: [], past_due: [], entries: [] },
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+export function managedConnectedAccountLink(account) {
+    return {
+        object: "v2.core.account_link",
+        account,
+        url: `https://connect.stripe.com/setup/e/${encodeURIComponent(account)}/onboarding`,
+        created: new Date().toISOString(),
+        expires_at: new Date(Date.now() + 3600_000).toISOString(),
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+export function managedConnectedAccountSession(params) {
+    return {
+        object: "account_session",
+        account: params.account,
+        client_secret: `accs_secret_muxo_${hexOf(params.account, 16)}`,
+        components: {
+            account_onboarding: { enabled: true },
+            ...(params.enableAccountManagement ? { account_management: { enabled: true } } : {}),
+            ...(params.enableNotificationBanner !== false ? { notification_banner: { enabled: true } } : {}),
+        },
+        expires_at: Math.floor(Date.now() / 1000) + 3600,
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+export function managedPaymentMethodRequest(params) {
+    return {
+        object: "v2.provisioning.payment_method_request",
+        checkout_session_url: `${params.publicWebUrl}/?checkout=payment_method_request`,
+        status: "checkout_initiated",
+        livemode: params.livemode,
+        source: "muxo_managed",
+    };
+}
+export const DEFAULT_PROVISIONING_EVENT_TYPES = [
+    "v2.provisioning.resource.completed",
+    "v2.provisioning.resource.errored",
+    "v2.core.account[requirements].updated",
+];
+export function managedEventDestination(params) {
+    return {
+        id: `ed_v2_${hexOf(params.url, 12)}`,
+        object: "v2.core.event_destination",
+        name: params.name || "Muxo Provisioning & Connect v2 Event Stream",
+        status: "enabled",
+        enabled_events: params.events?.length ? params.events : DEFAULT_PROVISIONING_EVENT_TYPES,
+        webhook_endpoint: { url: params.url },
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+/** What Muxo does with a Stripe v2 thin event, keyed by event type. */
+export function provisioningEventAction(eventType, hasRelatedObject) {
+    if (eventType === "v2.provisioning.resource.completed" && hasRelatedObject) {
+        return "revealed_access_configuration_and_synced_vault";
+    }
+    if (eventType === "v2.provisioning.resource.errored")
+        return "marked_resource_errored";
+    if (eventType === "v2.core.account[requirements].updated")
+        return "flagged_connected_account_requirements_due";
+    return "recorded_v2_event";
+}