@itzsudhan/creem-expo 0.1.0

package/src/client/hooks/useCreemCheckout.ts

@@ -0,0 +1,478 @@
+import { useEffect, useReducer, useRef, useState } from "react";
+import * as Linking from "expo-linking";
+import * as WebBrowser from "expo-web-browser";
+import type { WebViewNavigation } from "react-native-webview/lib/WebViewTypes";
+import { CreemError } from "../../errors";
+import type {
+  CheckoutPresentation,
+  CheckoutVerificationResult,
+  CheckoutSessionResult,
+  CreateCheckoutInput,
+  LaunchCheckoutInput,
+  ResourceStatus,
+  StartCheckoutOptions,
+  VerifyCheckoutInput,
+  VerifyCheckoutOptions,
+} from "../../types";
+import { useCreemContext } from "../context";
+import {
+  appendMetadataToUrl,
+  buildCheckoutUrlFromSessionId,
+  buildReturnUrl,
+  buildSuccessResult,
+  detectCheckoutStatusFromUrl,
+} from "../utils/linking";
+import {
+  checkoutReducer,
+  initialCheckoutState,
+} from "../utils/checkoutState";
+
+type ActiveRedirects = {
+  successUrl: string;
+  cancelUrl?: string;
+};
+
+const DEFAULT_VERIFY_TIMEOUT_MS = 12_000;
+const DEFAULT_VERIFY_POLL_INTERVAL_MS = 1_200;
+
+const createDirectSession = (
+  input: LaunchCheckoutInput,
+  checkoutUrl: string,
+  successUrl: string
+): CheckoutSessionResult => {
+  const checkoutUrlObject = new URL(checkoutUrl);
+  const checkoutId =
+    input.sessionId ??
+    checkoutUrlObject.searchParams.get("session_id") ??
+    checkoutUrlObject.searchParams.get("checkout_id") ??
+    "direct_checkout";
+
+  return {
+    checkoutId,
+    checkoutUrl,
+    requestId: input.sessionId,
+    successUrl,
+    status: "pending",
+  };
+};
+
+const resolveDirectCheckoutUrl = (input: LaunchCheckoutInput) => {
+  if (input.checkoutUrl) {
+    return input.checkoutUrl;
+  }
+
+  if (input.sessionId) {
+    return buildCheckoutUrlFromSessionId(input.sessionId);
+  }
+
+  throw new CreemError(
+    "INVALID_CHECKOUT_OPTIONS",
+    "Provide either `checkoutUrl` or `sessionId` when launching an existing Creem checkout."
+  );
+};
+
+const normalizeCheckoutError = (
+  error: unknown,
+  code: "CHECKOUT_LAUNCH_FAILED" | "INVALID_CHECKOUT_OPTIONS",
+  fallbackMessage: string
+) => {
+  if (error instanceof CreemError) {
+    return error;
+  }
+
+  if (error instanceof Error) {
+    return new CreemError(code, error.message || fallbackMessage, {
+      cause: error,
+    });
+  }
+
+  return new CreemError(code, fallbackMessage, {
+    cause: error,
+  });
+};
+
+const normalizeVerificationError = (error: unknown, fallbackMessage: string) => {
+  if (error instanceof CreemError) {
+    return error;
+  }
+
+  if (error instanceof Error) {
+    return new CreemError("CHECKOUT_VERIFICATION_FAILED", error.message || fallbackMessage, {
+      cause: error,
+    });
+  }
+
+  return new CreemError("CHECKOUT_VERIFICATION_FAILED", fallbackMessage, {
+    cause: error,
+  });
+};
+
+const resolveVerifyOptions = (
+  value: boolean | VerifyCheckoutOptions | undefined
+): { enabled: boolean; pollIntervalMs: number; timeoutMs: number } => {
+  if (!value) {
+    return {
+      enabled: false,
+      pollIntervalMs: DEFAULT_VERIFY_POLL_INTERVAL_MS,
+      timeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
+    };
+  }
+
+  if (value === true) {
+    return {
+      enabled: true,
+      pollIntervalMs: DEFAULT_VERIFY_POLL_INTERVAL_MS,
+      timeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
+    };
+  }
+
+  return {
+    enabled: true,
+    pollIntervalMs: value.pollIntervalMs ?? DEFAULT_VERIFY_POLL_INTERVAL_MS,
+    timeoutMs: value.timeoutMs ?? DEFAULT_VERIFY_TIMEOUT_MS,
+  };
+};
+
+const wait = (timeMs: number) =>
+  new Promise<void>((resolve) => {
+    setTimeout(resolve, timeMs);
+  });
+
+export const __internal = {
+  createDirectSession,
+  resolveDirectCheckoutUrl,
+  normalizeCheckoutError,
+  normalizeVerificationError,
+  resolveVerifyOptions,
+  wait,
+};
+
+export const useCreemCheckout = () => {
+  const {
+    apiClient,
+    defaultPresentation,
+    returnPath,
+    defaultVerifyOnSuccess,
+    logger,
+  } = useCreemContext();
+  const [state, dispatch] = useReducer(checkoutReducer, initialCheckoutState);
+  const activeRedirectsRef = useRef<ActiveRedirects | null>(null);
+  const activeVerifyOptionsRef = useRef<boolean | VerifyCheckoutOptions | undefined>(
+    defaultVerifyOnSuccess
+  );
+  const [verification, setVerification] = useState<CheckoutVerificationResult | null>(null);
+  const [verificationStatus, setVerificationStatus] =
+    useState<ResourceStatus>("idle");
+  const [verificationError, setVerificationError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    WebBrowser.maybeCompleteAuthSession();
+  }, []);
+
+  const clearActiveCheckoutContext = () => {
+    activeRedirectsRef.current = null;
+    activeVerifyOptionsRef.current = defaultVerifyOnSuccess;
+  };
+
+  const clearVerification = () => {
+    setVerification(null);
+    setVerificationStatus("idle");
+    setVerificationError(null);
+  };
+
+  const setActiveRedirects = (
+    successUrl: string,
+    cancelUrl: string | undefined,
+    verifyOptions: boolean | VerifyCheckoutOptions | undefined
+  ) => {
+    activeRedirectsRef.current = {
+      successUrl,
+      cancelUrl,
+    };
+    activeVerifyOptionsRef.current = verifyOptions;
+  };
+
+  const runCheckoutVerification = async (
+    checkoutId: string,
+    options?: VerifyCheckoutOptions
+  ) => {
+    setVerificationStatus("loading");
+    setVerificationError(null);
+
+    const pollIntervalMs = options?.pollIntervalMs ?? DEFAULT_VERIFY_POLL_INTERVAL_MS;
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_VERIFY_TIMEOUT_MS;
+    const startedAt = Date.now();
+
+    try {
+      while (true) {
+        const nextVerification = await apiClient.verifyCheckout({
+          checkoutId,
+        });
+        setVerification(nextVerification);
+
+        if (nextVerification.verified || Date.now() - startedAt >= timeoutMs) {
+          setVerificationStatus("ready");
+          return nextVerification;
+        }
+
+        await wait(pollIntervalMs);
+      }
+    } catch (error) {
+      const normalizedError = normalizeVerificationError(
+        error,
+        "Failed to verify the Creem checkout after redirect."
+      );
+      setVerificationError(normalizedError);
+      setVerificationStatus("error");
+      logger?.error?.("creem checkout verification failed", normalizedError);
+      throw normalizedError;
+    }
+  };
+
+  const completeFromUrl = async (session: CheckoutSessionResult, url: string) => {
+    const verifyOptions = resolveVerifyOptions(activeVerifyOptionsRef.current);
+    clearActiveCheckoutContext();
+
+    let verificationResult: CheckoutVerificationResult | null = null;
+
+    if (verifyOptions.enabled) {
+      try {
+        verificationResult = await runCheckoutVerification(session.checkoutId, verifyOptions);
+      } catch {
+        verificationResult = null;
+      }
+    }
+
+    const result = buildSuccessResult(session, url, verificationResult);
+    dispatch({ type: "success", result });
+    logger?.info?.("creem checkout completed", result);
+    return result;
+  };
+
+  const cancelCheckout = (session?: CheckoutSessionResult, url?: string) => {
+    clearActiveCheckoutContext();
+    dispatch({ type: "cancelled", session });
+    logger?.info?.("creem checkout cancelled", {
+      url,
+      checkoutId: session?.checkoutId,
+    });
+    return session;
+  };
+
+  const detectReturnStatus = (url: string) => {
+    const activeRedirects = activeRedirectsRef.current;
+
+    if (!activeRedirects) {
+      return undefined;
+    }
+
+    return detectCheckoutStatusFromUrl(
+      url,
+      activeRedirects.successUrl,
+      activeRedirects.cancelUrl
+    );
+  };
+
+  const presentCheckout = async (
+    session: CheckoutSessionResult,
+    redirects: ActiveRedirects,
+    presentation: CheckoutPresentation,
+    verifyOptions: boolean | VerifyCheckoutOptions | undefined
+  ) => {
+    setActiveRedirects(redirects.successUrl, redirects.cancelUrl, verifyOptions);
+
+    if (presentation === "webview") {
+      dispatch({
+        type: "present",
+        session,
+        returnUrl: redirects.successUrl,
+      });
+      return session;
+    }
+
+    dispatch({ type: "browser-session", session });
+    const browserResult = await WebBrowser.openAuthSessionAsync(
+      session.checkoutUrl,
+      redirects.successUrl
+    );
+
+    if (browserResult.type === "success" && "url" in browserResult && browserResult.url) {
+      const detectedStatus = detectReturnStatus(browserResult.url);
+
+      if (detectedStatus === "cancelled") {
+        return cancelCheckout(session, browserResult.url);
+      }
+
+      return completeFromUrl(session, browserResult.url);
+    }
+
+    if (browserResult.type === "cancel" || browserResult.type === "dismiss") {
+      cancelCheckout(session);
+      return session;
+    }
+
+    return session;
+  };
+
+  const startCheckout = async (
+    input: CreateCheckoutInput,
+    options?: StartCheckoutOptions
+  ) => {
+    clearVerification();
+    dispatch({ type: "start" });
+
+    try {
+      const resolvedReturnUrl =
+        input.returnUrl ??
+        buildReturnUrl(options?.returnPath ?? returnPath, Linking.createURL);
+      const session = await apiClient.createCheckoutSession({
+        ...input,
+        returnUrl: resolvedReturnUrl,
+      });
+
+      return await presentCheckout(
+        session,
+        {
+          successUrl: resolvedReturnUrl,
+        },
+        options?.presentation ?? defaultPresentation,
+        options?.verifyOnSuccess ?? defaultVerifyOnSuccess
+      );
+    } catch (error) {
+      clearActiveCheckoutContext();
+      const normalizedError = normalizeCheckoutError(
+        error,
+        "CHECKOUT_LAUNCH_FAILED",
+        "Failed to start the Creem checkout."
+      );
+      logger?.error?.("creem checkout failed", normalizedError);
+      dispatch({ type: "error", error: normalizedError });
+      throw normalizedError;
+    }
+  };
+
+  const launchCheckout = async (
+    input: LaunchCheckoutInput,
+    options?: StartCheckoutOptions
+  ) => {
+    clearVerification();
+    dispatch({ type: "start" });
+
+    try {
+      const successUrl =
+        input.returnUrl ??
+        buildReturnUrl(options?.returnPath ?? returnPath, Linking.createURL);
+      const cancelUrl =
+        input.cancelUrl ??
+        buildReturnUrl(options?.cancelPath ?? "creem/cancel", Linking.createURL);
+      const checkoutUrl = appendMetadataToUrl(
+        resolveDirectCheckoutUrl(input),
+        input.metadata
+      );
+      const session = createDirectSession(input, checkoutUrl, successUrl);
+
+      return await presentCheckout(
+        session,
+        {
+          successUrl,
+          cancelUrl,
+        },
+        options?.presentation ?? defaultPresentation,
+        options?.verifyOnSuccess ?? defaultVerifyOnSuccess
+      );
+    } catch (error) {
+      clearActiveCheckoutContext();
+      const normalizedError = normalizeCheckoutError(
+        error,
+        error instanceof CreemError &&
+          error.code === "INVALID_CHECKOUT_OPTIONS"
+          ? "INVALID_CHECKOUT_OPTIONS"
+          : "CHECKOUT_LAUNCH_FAILED",
+        "Failed to launch the Creem checkout."
+      );
+      logger?.error?.("creem direct checkout failed", normalizedError);
+      dispatch({ type: "error", error: normalizedError });
+      throw normalizedError;
+    }
+  };
+
+  const handleReturnUrl = (url: string) => {
+    if (!state.session) {
+      return false;
+    }
+
+    const detectedStatus = detectReturnStatus(url);
+
+    if (!detectedStatus) {
+      return false;
+    }
+
+    if (detectedStatus === "success") {
+      completeFromUrl(state.session, url);
+      return true;
+    }
+
+    cancelCheckout(state.session, url);
+    return true;
+  };
+
+  const handleWebViewNavigation = (navigation: Pick<WebViewNavigation, "url">) =>
+    handleReturnUrl(navigation.url);
+
+  const verifyCheckout = async (
+    input?: VerifyCheckoutInput,
+    options?: VerifyCheckoutOptions
+  ) => {
+    const checkoutId = input?.checkoutId ?? state.session?.checkoutId;
+
+    if (!checkoutId) {
+      throw new CreemError(
+        "CHECKOUT_VERIFICATION_FAILED",
+        "No Creem checkout is available to verify yet."
+      );
+    }
+
+    return runCheckoutVerification(checkoutId, options);
+  };
+
+  const dismiss = () => {
+    cancelCheckout(state.session ?? undefined);
+  };
+
+  const reset = () => {
+    clearActiveCheckoutContext();
+    clearVerification();
+    dispatch({ type: "reset" });
+  };
+
+  return {
+    status: state.status,
+    loading: state.status === "creating" || verificationStatus === "loading",
+    verifying: verificationStatus === "loading",
+    error: state.error,
+    session: state.session,
+    result: state.result,
+    verification,
+    verificationStatus,
+    verificationError,
+    webViewState: {
+      visible: state.webViewVisible,
+      checkoutUrl: state.session?.checkoutUrl ?? null,
+      returnUrl: state.webViewReturnUrl,
+    },
+    modalVisible: state.webViewVisible,
+    modalProps: {
+      visible: state.webViewVisible,
+      checkoutUrl: state.session?.checkoutUrl ?? null,
+      onRequestClose: dismiss,
+      onReturnUrl: handleReturnUrl,
+    },
+    startCheckout,
+    launchCheckout,
+    verifyCheckout,
+    handleReturnUrl,
+    handleWebViewNavigation,
+    dismiss,
+    reset,
+  };
+};

package/src/client/hooks/useCreemSubscription.ts

@@ -0,0 +1,194 @@
+import { useEffect, useState } from "react";
+import * as WebBrowser from "expo-web-browser";
+import { CreemError } from "../../errors";
+import { useCreemContext } from "../context";
+import type {
+  CancelSubscriptionInput,
+  CustomerPortalResult,
+  PortalStatus,
+  SubscriptionActionName,
+  SubscriptionMutationStatus,
+  ResourceStatus,
+  PauseSubscriptionInput,
+  ResumeSubscriptionInput,
+  SubscriptionSnapshot,
+  UseCreemSubscriptionOptions,
+  UpgradeSubscriptionInput,
+} from "../../types";
+
+export const useCreemSubscription = (
+  options?: UseCreemSubscriptionOptions
+) => {
+  const { apiClient, logger } = useCreemContext();
+  const [status, setStatus] = useState<ResourceStatus>("idle");
+  const [actionStatus, setActionStatus] =
+    useState<SubscriptionMutationStatus>("idle");
+  const [portalStatus, setPortalStatus] = useState<PortalStatus>("idle");
+  const [subscription, setSubscription] = useState<SubscriptionSnapshot | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const [portal, setPortal] = useState<CustomerPortalResult | null>(null);
+  const [lastAction, setLastAction] = useState<SubscriptionActionName | null>(null);
+
+  const normalizeError = (
+    value: unknown,
+    code:
+      | "PORTAL_OPEN_FAILED"
+      | "SUBSCRIPTION_FETCH_FAILED"
+      | "SUBSCRIPTION_MUTATION_FAILED",
+    fallback: string
+  ) => {
+    if (value instanceof CreemError) {
+      return value;
+    }
+
+    if (value instanceof Error) {
+      return new CreemError(code, value.message || fallback, {
+        cause: value,
+      });
+    }
+
+    return new CreemError(code, fallback, {
+      cause: value,
+    });
+  };
+
+  const refresh = async () => {
+    try {
+      setStatus("loading");
+      setError(null);
+      setLastAction("refresh");
+      const nextSubscription = await apiClient.getSubscription();
+      setSubscription(nextSubscription);
+      setStatus("ready");
+      return nextSubscription;
+    } catch (refreshError) {
+      const normalizedError = normalizeError(
+        refreshError,
+        "SUBSCRIPTION_FETCH_FAILED",
+        "Failed to load Creem subscription."
+      );
+      setStatus("error");
+      setError(normalizedError);
+      logger?.error?.("creem subscription refresh failed", normalizedError);
+      throw normalizedError;
+    }
+  };
+
+  const runMutation = async <TInput>(
+    action: SubscriptionActionName,
+    operation: (input: TInput) => Promise<SubscriptionSnapshot>,
+    input: TInput,
+    fallbackMessage: string
+  ) => {
+    try {
+      setActionStatus("loading");
+      setError(null);
+      setLastAction(action);
+      const nextSubscription = await operation(input);
+      setSubscription(nextSubscription);
+      setStatus("ready");
+      setActionStatus("ready");
+      return nextSubscription;
+    } catch (mutationError) {
+      const typedError = normalizeError(
+        mutationError,
+        "SUBSCRIPTION_MUTATION_FAILED",
+        fallbackMessage
+      );
+      setActionStatus("error");
+      setError(typedError);
+      logger?.error?.(`creem subscription ${action} failed`, typedError);
+      throw typedError;
+    }
+  };
+
+  useEffect(() => {
+    if (options?.enabled === false || options?.autoFetch === false) {
+      return;
+    }
+
+    refresh().catch(() => {
+      // The hook already stores the error state.
+    });
+  }, [options?.autoFetch, options?.enabled]);
+
+  const openPortal = async () => {
+    try {
+      setPortalStatus("opening");
+      const nextPortal = await apiClient.createCustomerPortal();
+      setPortal(nextPortal);
+      const browserResult = await WebBrowser.openBrowserAsync(
+        nextPortal.customerPortalLink
+      );
+
+      if (browserResult.type === "cancel" || browserResult.type === "dismiss") {
+        setPortalStatus("cancelled");
+        return nextPortal;
+      }
+
+      setPortalStatus("opened");
+      return nextPortal;
+    } catch (portalError) {
+      const normalizedError = normalizeError(
+        portalError,
+        "PORTAL_OPEN_FAILED",
+        "Failed to open Creem customer portal."
+      );
+      setPortalStatus("error");
+      setError(normalizedError);
+      logger?.error?.("creem portal open failed", normalizedError);
+      throw normalizedError;
+    }
+  };
+
+  const cancel = (input: CancelSubscriptionInput = {}) =>
+    runMutation(
+      "cancel",
+      apiClient.cancelSubscription,
+      input,
+      "Failed to cancel the Creem subscription."
+    );
+
+  const pause = (input: PauseSubscriptionInput = {}) =>
+    runMutation(
+      "pause",
+      apiClient.pauseSubscription,
+      input,
+      "Failed to pause the Creem subscription."
+    );
+
+  const resume = (input: ResumeSubscriptionInput = {}) =>
+    runMutation(
+      "resume",
+      apiClient.resumeSubscription,
+      input,
+      "Failed to resume the Creem subscription."
+    );
+
+  const upgrade = (input: UpgradeSubscriptionInput) =>
+    runMutation(
+      "upgrade",
+      apiClient.upgradeSubscription,
+      input,
+      "Failed to upgrade the Creem subscription."
+    );
+
+  return {
+    status,
+    loading: status === "loading",
+    actionStatus,
+    portalStatus,
+    lastAction,
+    subscription,
+    portal,
+    error,
+    refresh,
+    getSubscription: refresh,
+    cancel,
+    cancelSubscription: cancel,
+    pause,
+    resume,
+    upgrade,
+    openPortal,
+  };
+};