@itzsudhan/creem-expo 0.1.0

package/src/client/utils/checkoutState.ts

@@ -0,0 +1,99 @@
+import type {
+  CheckoutFlowResult,
+  CheckoutSessionResult,
+  CheckoutStatus,
+} from "../../types";
+
+export type CheckoutState = {
+  status: CheckoutStatus;
+  error: Error | null;
+  session: CheckoutSessionResult | null;
+  result: CheckoutFlowResult | null;
+  webViewVisible: boolean;
+  webViewReturnUrl: string | null;
+};
+
+export type CheckoutAction =
+  | { type: "start" }
+  | { type: "present"; session: CheckoutSessionResult; returnUrl: string }
+  | { type: "browser-session"; session: CheckoutSessionResult }
+  | { type: "success"; result: CheckoutFlowResult }
+  | { type: "cancelled"; session?: CheckoutSessionResult }
+  | { type: "error"; error: Error }
+  | { type: "reset" };
+
+export const initialCheckoutState: CheckoutState = {
+  status: "idle",
+  error: null,
+  session: null,
+  result: null,
+  webViewVisible: false,
+  webViewReturnUrl: null,
+};
+
+export const checkoutReducer = (
+  state: CheckoutState,
+  action: CheckoutAction
+): CheckoutState => {
+  switch (action.type) {
+    case "start":
+      return {
+        ...state,
+        status: "creating",
+        error: null,
+        result: null,
+        webViewVisible: false,
+        webViewReturnUrl: null,
+      };
+    case "present":
+      return {
+        ...state,
+        session: action.session,
+        status: "presented",
+        webViewVisible: true,
+        webViewReturnUrl: action.returnUrl,
+      };
+    case "browser-session":
+      return {
+        ...state,
+        session: action.session,
+        status: "presented",
+        webViewVisible: false,
+        webViewReturnUrl: null,
+      };
+    case "success":
+      return {
+        ...state,
+        status: "success",
+        error: null,
+        result: action.result,
+        session: action.result.session ?? null,
+        webViewVisible: false,
+        webViewReturnUrl: null,
+      };
+    case "cancelled":
+      return {
+        ...state,
+        status: "cancelled",
+        result: {
+          type: "cancelled",
+          session: action.session ?? state.session ?? undefined,
+        },
+        session: action.session ?? state.session ?? null,
+        webViewVisible: false,
+        webViewReturnUrl: null,
+      };
+    case "error":
+      return {
+        ...state,
+        status: "error",
+        error: action.error,
+        webViewVisible: false,
+        webViewReturnUrl: null,
+      };
+    case "reset":
+      return initialCheckoutState;
+    default:
+      return state;
+  }
+};

package/src/client/utils/linking.ts

@@ -0,0 +1,232 @@
+import * as Linking from "expo-linking";
+import type {
+  CheckoutRedirectStatus,
+  CheckoutReturnParams,
+  CheckoutSessionResult,
+  CheckoutVerificationResult,
+  CreateCreemRedirectOptions,
+  CreemRedirectUrls,
+  JsonValue,
+} from "../../types";
+
+const STATUS_QUERY_KEYS = ["status", "checkout_status", "creem_status"];
+const SUCCESS_QUERY_VALUES = new Set(["complete", "completed", "paid", "success"]);
+const CANCEL_QUERY_VALUES = new Set([
+  "abort",
+  "abandoned",
+  "cancel",
+  "cancelled",
+  "canceled",
+  "dismiss",
+  "dismissed",
+  "failed",
+]);
+
+const normalizePath = (path?: string | null) => {
+  if (!path) {
+    return "";
+  }
+
+  const trimmed = path.replace(/^\/+|\/+$/g, "");
+  return trimmed ? `/${trimmed}` : "";
+};
+
+const normalizeUrl = (rawUrl: string) => {
+  try {
+    const parsed = Linking.parse(rawUrl);
+    const scheme = parsed.scheme ? `${parsed.scheme.toLowerCase()}://` : "";
+    const host = parsed.hostname ? parsed.hostname.toLowerCase() : "";
+    const path = normalizePath(parsed.path);
+
+    return `${scheme}${host}${path}`;
+  } catch {
+    return "";
+  }
+};
+
+const toStringValue = (
+  value: JsonValue | string | string[] | undefined
+): string | undefined => {
+  if (Array.isArray(value)) {
+    return typeof value[0] === "string" ? value[0] : undefined;
+  }
+
+  return typeof value === "string" ? value : value == null ? undefined : String(value);
+};
+
+const stringifyMetadataValue = (value: JsonValue) => {
+  if (
+    value === null ||
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+  ) {
+    return value === null ? "null" : String(value);
+  }
+
+  return JSON.stringify(value);
+};
+
+const readStatusFromQuery = (
+  url: string
+): CheckoutRedirectStatus | undefined => {
+  const parsed = Linking.parse(url);
+  const query = parsed.queryParams ?? {};
+
+  for (const key of STATUS_QUERY_KEYS) {
+    const rawValue = toStringValue(query[key]);
+
+    if (!rawValue) {
+      continue;
+    }
+
+    const normalized = rawValue.toLowerCase();
+
+    if (SUCCESS_QUERY_VALUES.has(normalized)) {
+      return "success";
+    }
+
+    if (CANCEL_QUERY_VALUES.has(normalized)) {
+      return "cancelled";
+    }
+  }
+
+  return undefined;
+};
+
+const setSearchParam = (rawUrl: string, key: string, value: string) => {
+  try {
+    const parsed = new URL(rawUrl);
+    parsed.searchParams.set(key, value);
+    return parsed.toString();
+  } catch {
+    const [base, existingQuery = ""] = rawUrl.split("?");
+    const params = new URLSearchParams(existingQuery);
+    params.set(key, value);
+    return `${base}?${params.toString()}`;
+  }
+};
+
+export const __internal = {
+  normalizePath,
+  normalizeUrl,
+  toStringValue,
+  stringifyMetadataValue,
+  readStatusFromQuery,
+  setSearchParam,
+};
+
+export const buildReturnUrl = (
+  returnPath: string,
+  createUrl: (path: string) => string
+) => createUrl(returnPath);
+
+export const buildCheckoutUrlFromSessionId = (
+  sessionId: string,
+  checkoutBaseUrl = "https://www.creem.io/checkout"
+) => {
+  const parsed = new URL(checkoutBaseUrl);
+  parsed.searchParams.set("session_id", sessionId);
+  return parsed.toString();
+};
+
+export const createCreemRedirectUrls = (
+  scheme: string,
+  options: CreateCreemRedirectOptions = {}
+): CreemRedirectUrls => {
+  const successPath = options.successPath ?? "creem/callback";
+  const cancelPath = options.cancelPath ?? "creem/cancel";
+
+  return {
+    successUrl: Linking.createURL(successPath, { scheme }),
+    cancelUrl: Linking.createURL(cancelPath, { scheme }),
+    successPath,
+    cancelPath,
+  };
+};
+
+export const matchesReturnUrl = (candidateUrl: string, returnUrl: string) => {
+  const candidateNormalized = normalizeUrl(candidateUrl);
+  const returnNormalized = normalizeUrl(returnUrl);
+
+  if (!candidateNormalized || !returnNormalized) {
+    return false;
+  }
+
+  return (
+    candidateNormalized === returnNormalized ||
+    candidateNormalized.startsWith(`${returnNormalized}/`)
+  );
+};
+
+export const detectCheckoutStatusFromUrl = (
+  url: string,
+  successUrl?: string,
+  cancelUrl?: string
+): CheckoutRedirectStatus | undefined => {
+  const queryStatus = readStatusFromQuery(url);
+
+  if (queryStatus) {
+    return queryStatus;
+  }
+
+  if (successUrl && matchesReturnUrl(url, successUrl)) {
+    return "success";
+  }
+
+  if (cancelUrl && matchesReturnUrl(url, cancelUrl)) {
+    return "cancelled";
+  }
+
+  return undefined;
+};
+
+export const parseCheckoutReturnUrl = (url: string): CheckoutReturnParams => {
+  const parsed = new URL(url);
+  const entries = Object.fromEntries(parsed.searchParams.entries());
+
+  return {
+    ...entries,
+    checkoutId: entries.checkout_id ?? entries.checkoutId,
+    orderId: entries.order_id ?? entries.orderId,
+    customerId: entries.customer_id ?? entries.customerId,
+    subscriptionId: entries.subscription_id ?? entries.subscriptionId,
+    productId: entries.product_id ?? entries.productId,
+    signature: entries.signature,
+  };
+};
+
+export const appendMetadataToUrl = (
+  url: string,
+  metadata?: Record<string, JsonValue>
+) => {
+  if (!metadata || Object.keys(metadata).length === 0) {
+    return url;
+  }
+
+  return Object.entries(metadata).reduce(
+    (nextUrl, [key, value]) =>
+      setSearchParam(nextUrl, `meta_${key}`, stringifyMetadataValue(value)),
+    url
+  );
+};
+
+export const buildSuccessResult = (
+  session: CheckoutSessionResult,
+  returnUrl: string,
+  verification?: CheckoutVerificationResult | null
+) => ({
+  type: "success" as const,
+  session,
+  returnUrl,
+  params: parseCheckoutReturnUrl(returnUrl),
+  verification: verification ?? null,
+});
+
+export const getPrimaryReturnId = (params: CheckoutReturnParams) =>
+  params.subscriptionId ?? params.customerId ?? params.checkoutId;
+
+export const getReturnSignature = (url: string) => {
+  const parsed = new URL(url);
+  return toStringValue(parsed.searchParams.get("signature") ?? undefined);
+};

package/src/errors.ts

@@ -0,0 +1,61 @@
+export type CreemErrorCode =
+  | "CHECKOUT_CANCELLED"
+  | "CHECKOUT_LAUNCH_FAILED"
+  | "CHECKOUT_VERIFICATION_FAILED"
+  | "INVALID_CHECKOUT_OPTIONS"
+  | "PORTAL_OPEN_FAILED"
+  | "SUBSCRIPTION_FETCH_FAILED"
+  | "SUBSCRIPTION_MUTATION_FAILED";
+
+type CreemErrorOptions = {
+  cause?: unknown;
+  details?: unknown;
+};
+
+export class CreemError extends Error {
+  readonly code: CreemErrorCode;
+  readonly cause?: unknown;
+  readonly details?: unknown;
+
+  constructor(
+    code: CreemErrorCode,
+    message: string,
+    options: CreemErrorOptions = {}
+  ) {
+    super(message);
+    this.name = "CreemError";
+    this.code = code;
+    this.cause = options.cause;
+    this.details = options.details;
+  }
+}
+
+type CreemApiErrorOptions = {
+  status: number;
+  message: string;
+  code?: string | null;
+  details?: unknown;
+  responseBody?: string | null;
+  url?: string;
+  cause?: unknown;
+};
+
+export class CreemApiError extends Error {
+  readonly status: number;
+  readonly code?: string | null;
+  readonly details?: unknown;
+  readonly responseBody?: string | null;
+  readonly url?: string;
+  readonly cause?: unknown;
+
+  constructor(options: CreemApiErrorOptions) {
+    super(options.message);
+    this.name = "CreemApiError";
+    this.status = options.status;
+    this.code = options.code;
+    this.details = options.details;
+    this.responseBody = options.responseBody;
+    this.url = options.url;
+    this.cause = options.cause;
+  }
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+export * from "./types";
+export { CreemApiError, CreemError } from "./errors";
+export { createCreemApiClient } from "./client/apiClient";
+export { CreemProvider, useCreemContext } from "./client/context";
+export { useCreemCheckout } from "./client/hooks/useCreemCheckout";
+export { useCreemSubscription } from "./client/hooks/useCreemSubscription";
+export { CreemCheckoutButton } from "./client/components/CreemCheckoutButton";
+export { CreemCheckoutModal } from "./client/components/CreemCheckoutModal";
+export { CreemManageSubscriptionButton } from "./client/components/CreemManageSubscriptionButton";
+export { useCreemSubscription as useSubscription } from "./client/hooks/useCreemSubscription";
+export { CreemCheckoutModal as CreemCheckoutSheet } from "./client/components/CreemCheckoutModal";
+export {
+  appendMetadataToUrl,
+  buildCheckoutUrlFromSessionId,
+  createCreemRedirectUrls,
+  detectCheckoutStatusFromUrl,
+  matchesReturnUrl,
+  parseCheckoutReturnUrl,
+} from "./client/utils/linking";