@onborn/billing 0.1.0-beta.1

package/dist/useOnbornPaywall.js

@@ -0,0 +1,345 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { createBillingClient } from "./client";
+import { useOnbornBillingConfig } from "./runtime";
+import { findPackageWithProduct, getPackagesWithProducts, resolveDefaultPackageId, } from "./utils";
+import { validateBillingPurchase, validateBillingRestore } from "./validation";
+export function useOnbornPaywall(options) {
+    const runtimeOptions = useOnbornBillingConfig(options);
+    const [data, setData] = useState(null);
+    const [selectedPackageId, setSelectedPackageId] = useState(runtimeOptions.initialPackageId ?? null);
+    const [loading, setLoading] = useState(true);
+    const [purchasing, setPurchasing] = useState(false);
+    const [restoring, setRestoring] = useState(false);
+    const [error, setError] = useState(null);
+    const client = useMemo(() => createBillingClient({
+        sourceId: `paywall:${runtimeOptions.paywallId}`,
+    }), [
+        runtimeOptions.apiKey,
+        runtimeOptions.appId,
+        runtimeOptions.appVersion,
+        runtimeOptions.autoFlushMs,
+        runtimeOptions.country,
+        runtimeOptions.emitAnalyticsEvents,
+        runtimeOptions.emitSdkConnectionSignal,
+        runtimeOptions.fetchImpl,
+        runtimeOptions.locale,
+        runtimeOptions.paywallId,
+        runtimeOptions.platform,
+        runtimeOptions.sdkVersion,
+        runtimeOptions.userId,
+        runtimeOptions.userType,
+    ]);
+    const packages = useMemo(() => getPackagesWithProducts(data?.offering, data?.products, runtimeOptions.platform), [data?.offering, data?.products, runtimeOptions.platform]);
+    const selectedPackage = useMemo(() => {
+        const fallbackPackageId = selectedPackageId ?? resolveDefaultPackageId(data?.offering);
+        return findPackageWithProduct(packages, fallbackPackageId) ?? null;
+    }, [data?.offering, packages, selectedPackageId]);
+    const load = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const response = await client.loadPaywall(runtimeOptions.paywallId);
+            const products = await loadLocalizedProducts(runtimeOptions.billingAdapter, {
+                paywall: response.paywall,
+                offering: response.offering,
+                products: response.products,
+                userId: runtimeOptions.userId,
+            });
+            setData({ ...response, products });
+            setSelectedPackageId((current) => {
+                if (current &&
+                    response.offering?.packages.some((item) => item.id === current)) {
+                    return current;
+                }
+                return resolveDefaultPackageId(response.offering) ?? null;
+            });
+        }
+        catch (loadError) {
+            setError(toErrorMessage(loadError));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client, runtimeOptions.billingAdapter, runtimeOptions.paywallId, runtimeOptions.userId]);
+    useEffect(() => {
+        void load();
+    }, [load]);
+    const selectPackage = useCallback((packageId) => {
+        setSelectedPackageId(packageId);
+        if (!data?.paywall) {
+            return;
+        }
+        const product = findPackageWithProduct(packages, packageId)?.product;
+        void client
+            .trackPaywallPackageSelected({
+            sessionId: `paywall:${data.paywall.id}`,
+            stepId: `paywall:${data.paywall.id}:screen`,
+            paywallId: data.paywall.id,
+            paywallTemplate: data.paywall.name,
+            packageId,
+            productId: product?.storeProductId,
+        })
+            .then(() => client.flushEvents())
+            .catch(() => { });
+    }, [client, data, packages]);
+    const purchasePackageInternal = useCallback(async (packageId, intent = "purchase") => {
+        const item = findPackageWithProduct(packages, packageId) ?? selectedPackage;
+        if (!item || !data?.offering) {
+            throw new Error("No paywall package selected");
+        }
+        if (!runtimeOptions.billingAdapter) {
+            throw new Error("Missing ONBORN billingAdapter. Provide one to purchase from a custom paywall.");
+        }
+        if (intent === "trial") {
+            try {
+                const shouldContinue = await runtimeOptions.onStartTrial?.(item);
+                if (shouldContinue === false) {
+                    return { success: false, packageId: item.package.id };
+                }
+            }
+            catch (trialError) {
+                const errorObject = toError(trialError);
+                runtimeOptions.onPurchaseFailed?.(errorObject);
+                throw errorObject;
+            }
+        }
+        setPurchasing(true);
+        runtimeOptions.onPurchaseStarted?.(item);
+        const paywallSessionId = `paywall:${data.paywall.id}`;
+        const paywallStepId = `paywall:${data.paywall.id}:screen`;
+        const purchaseProductId = item.product?.storeProductId ?? item.package.productId;
+        void client
+            .trackPaywallPurchaseStarted({
+            sessionId: paywallSessionId,
+            stepId: paywallStepId,
+            paywallId: data.paywall.id,
+            paywallTemplate: data.paywall.name,
+            packageId: item.package.id,
+            productId: purchaseProductId,
+        })
+            .then(() => client.flushEvents())
+            .catch(() => { });
+        if (intent === "trial") {
+            void client
+                .trackPaywallTrialStarted({
+                sessionId: paywallSessionId,
+                stepId: paywallStepId,
+                paywallId: data.paywall.id,
+                paywallTemplate: data.paywall.name,
+                packageId: item.package.id,
+                productId: purchaseProductId,
+                trialPeriod: item.product?.trialPeriod,
+            })
+                .then(() => client.flushEvents())
+                .catch(() => { });
+        }
+        try {
+            const adapterResult = await runtimeOptions.billingAdapter.purchasePackage({
+                paywall: data.paywall,
+                offering: data.offering,
+                package: item.package,
+                product: item.product,
+                userId: runtimeOptions.userId,
+            });
+            const result = adapterResult.success
+                ? await validateBillingPurchase({
+                    client,
+                    paywall: data.paywall,
+                    offering: data.offering,
+                    item,
+                    result: adapterResult,
+                })
+                : adapterResult;
+            runtimeOptions.onPurchaseCompleted?.(result);
+            notifyEntitlementsChanged(result.entitlements, runtimeOptions.onEntitlementsChanged);
+            if (result.success && result.status === "validated") {
+                await client.trackPaywallConverted({
+                    sessionId: paywallSessionId,
+                    stepId: paywallStepId,
+                    paywallId: data.paywall.id,
+                    paywallTemplate: data.paywall.name,
+                    productId: purchaseProductId,
+                });
+                await client.flushEvents();
+            }
+            else if (!result.success) {
+                void client
+                    .trackPaywallPurchaseFailed({
+                    sessionId: paywallSessionId,
+                    stepId: paywallStepId,
+                    paywallId: data.paywall.id,
+                    paywallTemplate: data.paywall.name,
+                    reason: "error",
+                    packageId: item.package.id,
+                    productId: purchaseProductId,
+                })
+                    .then(() => client.flushEvents())
+                    .catch(() => { });
+            }
+            return result;
+        }
+        catch (purchaseError) {
+            const errorObject = toError(purchaseError);
+            runtimeOptions.onPurchaseFailed?.(errorObject);
+            void client
+                .trackPaywallPurchaseFailed({
+                sessionId: paywallSessionId,
+                stepId: paywallStepId,
+                paywallId: data.paywall.id,
+                paywallTemplate: data.paywall.name,
+                reason: classifyPurchaseFailureReason(purchaseError),
+                packageId: item.package.id,
+                productId: purchaseProductId,
+                message: errorObject.message,
+            })
+                .then(() => client.flushEvents())
+                .catch(() => { });
+            throw errorObject;
+        }
+        finally {
+            setPurchasing(false);
+        }
+    }, [client, data, runtimeOptions, packages, selectedPackage]);
+    const purchasePackage = useCallback((packageId) => purchasePackageInternal(packageId, "purchase"), [purchasePackageInternal]);
+    const startTrialPackage = useCallback((packageId) => purchasePackageInternal(packageId, "trial"), [purchasePackageInternal]);
+    const restorePurchases = useCallback(async () => {
+        if (!runtimeOptions.billingAdapter?.restorePurchases) {
+            throw new Error("Missing restorePurchases on ONBORN billingAdapter.");
+        }
+        setRestoring(true);
+        const restorePaywall = data?.paywall;
+        if (restorePaywall) {
+            void client
+                .trackPaywallRestoreStarted({
+                sessionId: `paywall:${restorePaywall.id}`,
+                stepId: `paywall:${restorePaywall.id}:screen`,
+                paywallId: restorePaywall.id,
+                paywallTemplate: restorePaywall.name,
+            })
+                .then(() => client.flushEvents())
+                .catch(() => { });
+        }
+        try {
+            const adapterResult = await runtimeOptions.billingAdapter.restorePurchases({
+                paywall: data?.paywall,
+                offering: data?.offering,
+                products: data?.products ?? [],
+                userId: runtimeOptions.userId,
+            });
+            const result = await validateBillingRestore({
+                client,
+                offering: data?.offering,
+                result: adapterResult,
+            });
+            runtimeOptions.onRestoreCompleted?.(result);
+            notifyEntitlementsChanged(result.entitlements, runtimeOptions.onEntitlementsChanged);
+            if (restorePaywall) {
+                void client
+                    .trackPaywallRestoreCompleted({
+                    sessionId: `paywall:${restorePaywall.id}`,
+                    stepId: `paywall:${restorePaywall.id}:screen`,
+                    paywallId: restorePaywall.id,
+                    paywallTemplate: restorePaywall.name,
+                    restored: Boolean(result.success),
+                })
+                    .then(() => client.flushEvents())
+                    .catch(() => { });
+            }
+            return result;
+        }
+        catch (restoreError) {
+            const errorObject = toError(restoreError);
+            runtimeOptions.onRestoreFailed?.(errorObject);
+            if (restorePaywall) {
+                void client
+                    .trackPaywallRestoreFailed({
+                    sessionId: `paywall:${restorePaywall.id}`,
+                    stepId: `paywall:${restorePaywall.id}:screen`,
+                    paywallId: restorePaywall.id,
+                    paywallTemplate: restorePaywall.name,
+                    message: errorObject.message,
+                })
+                    .then(() => client.flushEvents())
+                    .catch(() => { });
+            }
+            throw errorObject;
+        }
+        finally {
+            setRestoring(false);
+        }
+    }, [client, data, runtimeOptions]);
+    const refetchCustomerEntitlements = useCallback(async () => {
+        if (!runtimeOptions.billingAdapter?.refetchCustomerEntitlements) {
+            throw new Error("Missing refetchCustomerEntitlements on ONBORN billingAdapter.");
+        }
+        const adapterResult = await runtimeOptions.billingAdapter.refetchCustomerEntitlements({
+            userId: runtimeOptions.userId,
+        });
+        const result = await validateBillingRestore({
+            client,
+            offering: data?.offering,
+            result: adapterResult,
+        });
+        notifyEntitlementsChanged(result.entitlements, runtimeOptions.onEntitlementsChanged);
+        return result;
+    }, [client, data?.offering, runtimeOptions]);
+    return {
+        data,
+        packages,
+        selectedPackage,
+        selectedPackageId: selectedPackage?.package.id ?? null,
+        loading,
+        purchasing,
+        restoring,
+        error,
+        selectPackage,
+        reload: load,
+        purchasePackage,
+        startTrialPackage,
+        restorePurchases,
+        refetchCustomerEntitlements,
+    };
+}
+function toErrorMessage(error) {
+    return toError(error).message;
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error("Unknown error");
+}
+function classifyPurchaseFailureReason(error) {
+    if (error && typeof error === "object") {
+        const candidate = error;
+        if (candidate.userCancelled === true ||
+            candidate.userCancelled === "true") {
+            return "cancelled";
+        }
+        const code = typeof candidate.code === "string" ? candidate.code.toUpperCase() : "";
+        if (code.includes("CANCEL")) {
+            return "cancelled";
+        }
+        const message = typeof candidate.message === "string"
+            ? candidate.message.toLowerCase()
+            : "";
+        if (message.includes("cancel")) {
+            return "cancelled";
+        }
+    }
+    return "error";
+}
+async function loadLocalizedProducts(billingAdapter, input) {
+    if (!billingAdapter?.loadProducts) {
+        return input.products;
+    }
+    try {
+        return await billingAdapter.loadProducts(input);
+    }
+    catch {
+        return input.products;
+    }
+}
+function notifyEntitlementsChanged(entitlements, callback) {
+    if (!entitlements) {
+        return;
+    }
+    callback?.(entitlements);
+}

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+import type { BillingOffering, BillingPackage, BillingPlatform, BillingProduct } from "@onborn/sdk-contracts";
+import type { OnbornPackageWithProduct } from "./types";
+export declare function getPackagesWithProducts(offering: BillingOffering | undefined, products: BillingProduct[] | undefined, platform?: BillingPlatform): OnbornPackageWithProduct[];
+export declare function resolveDefaultPackageId(offering: BillingOffering | undefined): string | undefined;
+export declare function findPackageWithProduct(packages: OnbornPackageWithProduct[], packageId: string | undefined): OnbornPackageWithProduct | undefined;
+export declare function formatPackagePrice(product: BillingProduct | undefined, fallback?: string): string;
+export declare function getStoreProductId(billingPackage: BillingPackage, product: BillingProduct | undefined): string;
+export declare function formatBillingPeriod(period: string | undefined): string;

package/dist/utils.js

@@ -0,0 +1,58 @@
+import { resolvePackageProductId } from "@onborn/sdk-contracts";
+export function getPackagesWithProducts(offering, products, platform) {
+    if (!offering) {
+        return [];
+    }
+    const productList = products ?? [];
+    return [...offering.packages]
+        .sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0))
+        .map((billingPackage) => ({
+        package: billingPackage,
+        product: productList.find((product) => product.id === resolvePackageProductId(billingPackage, platform)),
+    }));
+}
+export function resolveDefaultPackageId(offering) {
+    if (!offering) {
+        return undefined;
+    }
+    return (offering.defaultPackageId ??
+        offering.packages.find((item) => item.isHighlighted)?.id ??
+        offering.packages[0]?.id);
+}
+export function findPackageWithProduct(packages, packageId) {
+    if (!packageId) {
+        return undefined;
+    }
+    return packages.find((item) => item.package.id === packageId);
+}
+export function formatPackagePrice(product, fallback = "") {
+    if (!product?.price) {
+        return fallback;
+    }
+    const period = formatBillingPeriod(product.period);
+    return period ? `${product.price} / ${period}` : product.price;
+}
+export function getStoreProductId(billingPackage, product) {
+    return product?.storeProductId ?? product?.id ?? billingPackage.productId;
+}
+export function formatBillingPeriod(period) {
+    switch (period?.toLowerCase()) {
+        case "p1w":
+        case "one_week":
+            return "week";
+        case "p1m":
+        case "one_month":
+            return "month";
+        case "p3m":
+        case "three_months":
+            return "3 months";
+        case "p6m":
+        case "six_months":
+            return "6 months";
+        case "p1y":
+        case "one_year":
+            return "year";
+        default:
+            return period ?? "";
+    }
+}

package/dist/validation.d.ts

@@ -0,0 +1,20 @@
+import type { PaywallConfig } from "@onborn/sdk-contracts";
+import type { BillingClient } from "./client";
+import type { OnbornPackageWithProduct, OnbornPurchaseResult, OnbornRestoreResult } from "./types";
+import type { BillingOffering } from "@onborn/sdk-contracts";
+export type BillingValidationClient = Pick<BillingClient, "validatePurchase" | "restorePurchases">;
+type ValidateBillingPurchaseInput = {
+    client: BillingValidationClient;
+    paywall?: PaywallConfig;
+    offering: BillingOffering;
+    item: OnbornPackageWithProduct;
+    result: OnbornPurchaseResult;
+};
+type ValidateBillingRestoreInput = {
+    client: BillingValidationClient;
+    offering?: BillingOffering;
+    result: OnbornRestoreResult;
+};
+export declare function validateBillingPurchase(input: ValidateBillingPurchaseInput): Promise<OnbornPurchaseResult>;
+export declare function validateBillingRestore(input: ValidateBillingRestoreInput): Promise<OnbornRestoreResult>;
+export {};

package/dist/validation.js

@@ -0,0 +1,60 @@
+export async function validateBillingPurchase(input) {
+    const product = input.item.product;
+    if (!product) {
+        throw new Error(`Missing product for ONBORN package '${input.item.package.id}'.`);
+    }
+    const response = await input.client.validatePurchase({
+        idempotencyKey: createPurchaseIdempotencyKey(input),
+        paywallId: input.paywall?.id,
+        offeringId: input.offering.id,
+        packageId: input.item.package.id,
+        productId: product.id,
+        storeProductId: product.storeProductId,
+        provider: input.offering.provider,
+        store: product.store,
+        transactionId: input.result.transactionId,
+        purchaseToken: input.result.purchaseToken,
+        receipt: input.result.receipt,
+        raw: input.result.raw,
+    });
+    return {
+        ...input.result,
+        status: response.status,
+        purchaseId: response.purchaseId,
+        entitlements: response.entitlements,
+        entitlementIds: response.entitlements.map((item) => item.key),
+    };
+}
+export async function validateBillingRestore(input) {
+    const response = await input.client.restorePurchases({
+        idempotencyKey: createRestoreIdempotencyKey(input),
+        provider: input.offering?.provider,
+        activeEntitlementKeys: input.result.entitlementIds,
+        activeProductIds: input.result.activeProductIds,
+        purchases: input.result.purchases,
+        raw: input.result.raw,
+    });
+    return {
+        ...input.result,
+        status: response.status,
+        purchaseId: response.purchaseId,
+        entitlements: response.entitlements,
+        entitlementIds: response.entitlements.map((item) => item.key),
+    };
+}
+function createPurchaseIdempotencyKey(input) {
+    const stablePart = input.result.transactionId ??
+        input.result.purchaseToken ??
+        input.result.productId ??
+        input.item.product?.storeProductId ??
+        input.item.package.id;
+    return [
+        "purchase",
+        input.offering.id,
+        input.item.package.id,
+        stablePart,
+    ].join(":");
+}
+function createRestoreIdempotencyKey(input) {
+    return ["restore", input.offering?.id ?? "unknown", String(Date.now())].join(":");
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@onborn/billing",
+  "version": "0.1.0-beta.1",
+  "description": "Headless billing, offerings, purchases, restores, and entitlements for Onborn.",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/onborn/onborn-react-native.git",
+    "directory": "packages/billing"
+  },
+  "bugs": {
+    "url": "https://github.com/onborn/onborn-react-native/issues"
+  },
+  "homepage": "https://github.com/onborn/onborn-react-native#readme",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "react-native": "./dist/index.js",
+  "exports": {
+    ".": {
+      "react-native": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc",
+    "lint": "eslint . --max-warnings 0",
+    "check-types": "tsc --noEmit",
+    "prepack": "yarn build"
+  },
+  "dependencies": {
+    "@onborn/analytics": "0.1.0-beta.2",
+    "@onborn/sdk-contracts": "0.1.0-beta.1"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.76.0"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "*",
+    "@repo/typescript-config": "*",
+    "@types/node": "^22.15.3",
+    "@types/react": "~19.2.4",
+    "eslint": "^9.39.1",
+    "react": "19.2.3",
+    "react-native": "0.86.0",
+    "typescript": "5.9.2"
+  }
+}