@itzsudhan/creem-expo 0.1.0

package/dist/chunk-BF74I2QD.mjs

@@ -0,0 +1,857 @@
+// src/server/express.ts
+import express, {
+  Router
+} from "express";
+
+// src/server/json.ts
+var CreemHttpError = class extends Error {
+  status;
+  details;
+  constructor(status, message, details) {
+    super(message);
+    this.status = status;
+    this.details = details;
+  }
+};
+var json = (body, init) => new Response(JSON.stringify(body), {
+  ...init,
+  headers: {
+    "content-type": "application/json; charset=utf-8",
+    ...init?.headers ?? {}
+  }
+});
+var errorResponse = (error) => {
+  if (error instanceof CreemHttpError) {
+    return json(
+      {
+        error: {
+          message: error.message,
+          details: error.details ?? null
+        }
+      },
+      { status: error.status }
+    );
+  }
+  return json(
+    {
+      error: {
+        message: error instanceof Error ? error.message : "An unexpected Creem server error occurred."
+      }
+    },
+    { status: 500 }
+  );
+};
+
+// src/server/signatures.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var verifyWebhookSignature = (rawBody, signature, secret) => {
+  const computedSignature = createHmac("sha256", secret).update(rawBody).digest("hex");
+  const providedBuffer = Buffer.from(signature, "hex");
+  const computedBuffer = Buffer.from(computedSignature, "hex");
+  if (providedBuffer.length !== computedBuffer.length) {
+    return false;
+  }
+  return timingSafeEqual(providedBuffer, computedBuffer);
+};
+
+// src/server/core.ts
+var KNOWN_WEBHOOK_HANDLER_KEYS = {
+  "checkout.completed": "onCheckoutCompleted",
+  "dispute.created": "onDisputeCreated",
+  "refund.created": "onRefundCreated",
+  "subscription.active": "onSubscriptionActive",
+  "subscription.canceled": "onSubscriptionCanceled",
+  "subscription.expired": "onSubscriptionExpired",
+  "subscription.paid": "onSubscriptionPaid",
+  "subscription.past_due": "onSubscriptionPastDue",
+  "subscription.paused": "onSubscriptionPaused",
+  "subscription.trialing": "onSubscriptionTrialing",
+  "subscription.unpaid": "onSubscriptionUnpaid",
+  "subscription.update": "onSubscriptionUpdate"
+};
+var CREEM_USER_ID_KEY = "creemExpoUserId";
+var nowIso = (clock) => (clock ? clock() : /* @__PURE__ */ new Date()).toISOString();
+var asRecord = (value) => typeof value === "object" && value !== null ? value : {};
+var asOptionalJsonObject = (value) => typeof value === "object" && value !== null ? value : void 0;
+var extractId = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value && typeof value === "object" && "id" in value) {
+    return typeof value.id === "string" ? value.id : void 0;
+  }
+  return void 0;
+};
+var extractCustomerEmail = (customer) => {
+  if (!customer || typeof customer !== "object" || !("email" in customer)) {
+    return void 0;
+  }
+  return typeof customer.email === "string" ? customer.email : void 0;
+};
+var mergeMetadata = (metadata, identity) => ({
+  ...metadata ?? {},
+  [CREEM_USER_ID_KEY]: identity.userId
+});
+var isHttpUrl = (value) => {
+  if (!value) {
+    return false;
+  }
+  try {
+    const protocol = new URL(value).protocol;
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
+  }
+};
+var mapCheckoutEntity = (checkout) => ({
+  checkoutId: checkout.id,
+  checkoutUrl: checkout.checkoutUrl ?? "",
+  productId: extractId(checkout.product),
+  requestId: checkout.requestId,
+  successUrl: checkout.successUrl ?? null,
+  status: checkout.status,
+  mode: checkout.mode,
+  customerId: extractId(checkout.customer) ?? null,
+  subscriptionId: extractId(checkout.subscription) ?? null,
+  rawCheckout: checkout
+});
+var mapPortalEntity = (portal, customerId) => ({
+  customerId,
+  customerPortalLink: portal.customerPortalLink,
+  rawPortal: portal
+});
+var isEntitledFromStatus = (status) => status === "active" || status === "trialing" || status === "paid" || status === "scheduled_cancel";
+var isVerifiedCheckoutStatus = (status) => status === "complete" || status === "completed" || status === "paid" || status === "success" || status === "succeeded";
+var buildCheckoutVerification = (checkoutId, checkout, userState) => {
+  const matchesLatestCheckout = userState?.latestCheckoutId === checkoutId;
+  const source = checkout ? "checkout" : matchesLatestCheckout ? "subscription" : "none";
+  const verified = isVerifiedCheckoutStatus(checkout?.status) || Boolean(
+    (matchesLatestCheckout || checkout) && (checkout?.orderId ?? checkout?.subscriptionId ?? userState?.latestOrderId ?? userState?.subscriptionId ?? (userState?.entitlementActive ? "entitled" : null))
+  );
+  return {
+    checkoutId,
+    verified,
+    source,
+    checkoutStatus: checkout?.status ?? null,
+    customerId: checkout?.customerId ?? userState?.customerId ?? null,
+    subscriptionId: checkout?.subscriptionId ?? userState?.subscriptionId ?? null,
+    orderId: checkout?.orderId ?? userState?.latestOrderId ?? null,
+    productId: checkout?.productId ?? userState?.latestProductId ?? null,
+    entitlementActive: userState?.entitlementActive ?? false,
+    subscriptionStatus: userState?.subscriptionStatus ?? null,
+    updatedAt: checkout?.updatedAt ?? userState?.updatedAt ?? null
+  };
+};
+var normalizeWebhookEvent = (payload) => {
+  const record = asRecord(payload);
+  const object = asRecord(record.object);
+  if (typeof record.id !== "string" || typeof record.eventType !== "string") {
+    throw new CreemHttpError(400, "Creem webhook payload is missing required fields.");
+  }
+  const createdAt = typeof record.created_at === "number" ? record.created_at : typeof record.createdAt === "number" ? record.createdAt : Date.now();
+  return {
+    id: record.id,
+    eventType: record.eventType,
+    createdAt,
+    object
+  };
+};
+var buildUserState = (currentState, patch, clock) => ({
+  userId: patch.userId ?? currentState?.userId ?? "",
+  email: patch.email ?? currentState?.email ?? null,
+  customerId: patch.customerId ?? currentState?.customerId ?? null,
+  subscriptionId: patch.subscriptionId ?? currentState?.subscriptionId ?? null,
+  latestCheckoutId: patch.latestCheckoutId ?? currentState?.latestCheckoutId ?? null,
+  latestOrderId: patch.latestOrderId ?? currentState?.latestOrderId ?? null,
+  latestProductId: patch.latestProductId ?? currentState?.latestProductId ?? null,
+  entitlementActive: patch.entitlementActive ?? currentState?.entitlementActive ?? false,
+  subscriptionStatus: patch.subscriptionStatus ?? currentState?.subscriptionStatus ?? null,
+  metadata: patch.metadata ?? currentState?.metadata ?? null,
+  subscription: patch.subscription ?? currentState?.subscription ?? null,
+  updatedAt: nowIso(clock)
+});
+var buildCheckoutRecord = (session, userId, input, clock) => {
+  const timestamp = nowIso(clock);
+  return {
+    checkoutId: session.checkoutId,
+    userId,
+    productId: session.productId ?? input.productId,
+    requestId: session.requestId ?? input.requestId,
+    status: session.status,
+    checkoutUrl: session.checkoutUrl,
+    successUrl: session.successUrl ?? input.returnUrl ?? null,
+    customerId: session.customerId ?? input.customer?.id ?? null,
+    subscriptionId: session.subscriptionId ?? null,
+    orderId: null,
+    metadata: input.metadata ?? null,
+    createdAt: timestamp,
+    updatedAt: timestamp
+  };
+};
+var resolveIdentityFromWebhook = async (store, event) => {
+  const metadata = asRecord(event.object.metadata);
+  const explicitUserId = metadata[CREEM_USER_ID_KEY];
+  if (typeof explicitUserId === "string") {
+    return store.getUserState(explicitUserId);
+  }
+  const subscriptionId = extractId(event.object.subscription);
+  if (subscriptionId) {
+    const fromSubscription = await store.getUserStateBySubscriptionId(subscriptionId);
+    if (fromSubscription) {
+      return fromSubscription;
+    }
+  }
+  const customerId = extractId(event.object.customer);
+  if (customerId) {
+    const fromCustomer = await store.getUserStateByCustomerId(customerId);
+    if (fromCustomer) {
+      return fromCustomer;
+    }
+  }
+  const checkoutId = extractId(event.object);
+  if (checkoutId) {
+    const checkout = await store.getCheckout(checkoutId);
+    if (checkout) {
+      return store.getUserState(checkout.userId);
+    }
+  }
+  return null;
+};
+var buildSubscriptionSnapshot = (userId, state, subscription) => ({
+  userId,
+  email: state?.email ?? null,
+  customerId: state?.customerId ?? null,
+  subscriptionId: state?.subscriptionId ?? null,
+  latestCheckoutId: state?.latestCheckoutId ?? null,
+  latestOrderId: state?.latestOrderId ?? null,
+  latestProductId: state?.latestProductId ?? null,
+  entitlementActive: state?.entitlementActive ?? false,
+  subscriptionStatus: subscription?.status ?? state?.subscriptionStatus ?? null,
+  source: subscription ? "creem" : state ? "store" : "none",
+  subscription: subscription ?? state?.subscription ?? null,
+  metadata: state?.metadata ?? null,
+  updatedAt: state?.updatedAt ?? null
+});
+var buildSubscriptionStatePatch = ({
+  userState,
+  identity,
+  subscription,
+  fallbackProductId
+}) => ({
+  userId: identity.userId,
+  email: identity.email ?? userState?.email ?? null,
+  customerId: extractId(subscription.customer) ?? userState?.customerId ?? identity.customerId ?? null,
+  subscriptionId: subscription.id,
+  latestProductId: extractId(subscription.product) ?? fallbackProductId ?? userState?.latestProductId ?? null,
+  subscriptionStatus: subscription.status,
+  entitlementActive: isEntitledFromStatus(subscription.status),
+  subscription
+});
+var createCreemServerCore = ({
+  creem,
+  store,
+  webhookSecret,
+  resolveIdentity,
+  buildSuccessUrl,
+  onWebhookEvent,
+  webhookHandlers,
+  now,
+  ...namedWebhookHandlers
+}) => {
+  const resolveRequestIdentity = async ({
+    request,
+    platformContext
+  }) => resolveIdentity({
+    request,
+    platformContext
+  });
+  const dispatchWebhookHandlers = async (context) => {
+    const handlerFromMap = webhookHandlers?.[context.event.eventType];
+    if (handlerFromMap) {
+      await handlerFromMap(context);
+    }
+    const handlerKey = KNOWN_WEBHOOK_HANDLER_KEYS[context.event.eventType];
+    const namedHandler = handlerKey ? namedWebhookHandlers[handlerKey] : void 0;
+    if (namedHandler) {
+      await namedHandler(context);
+    }
+    if (onWebhookEvent) {
+      await onWebhookEvent(context);
+    }
+  };
+  return {
+    async createCheckoutSession({
+      request,
+      input,
+      platformContext
+    }) {
+      const identity = await resolveRequestIdentity({ request, platformContext });
+      const userState = await store.getUserState(identity.userId);
+      const successUrl = isHttpUrl(input.returnUrl) ? input.returnUrl : await buildSuccessUrl({
+        request,
+        platformContext,
+        identity,
+        input,
+        userState
+      });
+      const checkout = await creem.checkouts.create({
+        productId: input.productId,
+        requestId: input.requestId,
+        units: input.units,
+        discountCode: input.discountCode,
+        customer: {
+          id: input.customer?.id ?? userState?.customerId ?? identity.customerId ?? void 0,
+          email: input.customer?.email ?? identity.email ?? userState?.email ?? void 0
+        },
+        customFields: input.customFields,
+        successUrl,
+        metadata: mergeMetadata(input.metadata, identity)
+      });
+      const session = mapCheckoutEntity(checkout);
+      await store.saveCheckout(buildCheckoutRecord(session, identity.userId, input, now));
+      const nextState = buildUserState(
+        userState,
+        {
+          userId: identity.userId,
+          email: input.customer?.email ?? identity.email ?? userState?.email ?? null,
+          customerId: session.customerId ?? userState?.customerId ?? identity.customerId ?? null,
+          latestCheckoutId: session.checkoutId,
+          latestProductId: session.productId ?? input.productId,
+          metadata: mergeMetadata(input.metadata, identity)
+        },
+        now
+      );
+      await store.saveUserState(nextState);
+      return session;
+    },
+    async getSubscriptionSnapshot({
+      request,
+      platformContext
+    }) {
+      const identity = await resolveRequestIdentity({ request, platformContext });
+      const userState = await store.getUserState(identity.userId);
+      if (!userState?.subscriptionId) {
+        return buildSubscriptionSnapshot(identity.userId, userState, null);
+      }
+      try {
+        const subscription = await creem.subscriptions.get(userState.subscriptionId);
+        const nextState = buildUserState(
+          userState,
+          buildSubscriptionStatePatch({
+            userState,
+            identity,
+            subscription
+          }),
+          now
+        );
+        await store.saveUserState(nextState);
+        return buildSubscriptionSnapshot(identity.userId, nextState, subscription);
+      } catch {
+        return buildSubscriptionSnapshot(identity.userId, userState, null);
+      }
+    },
+    async verifyCheckoutSession({
+      request,
+      input,
+      platformContext
+    }) {
+      const identity = await resolveRequestIdentity({ request, platformContext });
+      const userState = await store.getUserState(identity.userId);
+      const checkout = await store.getCheckout(input.checkoutId);
+      const checkoutForUser = checkout && checkout.userId === identity.userId ? checkout : null;
+      return buildCheckoutVerification(input.checkoutId, checkoutForUser, userState);
+    },
+    async cancelSubscription({
+      request,
+      input,
+      platformContext
+    }) {
+      const identity = await resolveRequestIdentity({ request, platformContext });
+      const userState = await store.getUserState(identity.userId);
+      const subscriptionId = input.subscriptionId ?? userState?.subscriptionId;
+      if (!subscriptionId) {
+        throw new CreemHttpError(
+          400,
+          "No Creem subscription is linked to the current user yet."
+        );
+      }
+      const subscription = await creem.subscriptions.cancel(subscriptionId, {
+        mode: input.mode,
+        onExecute: input.onExecute
+      });
+      const nextState = buildUserState(
+        userState,
+        buildSubscriptionStatePatch({
+          userState,
+          identity,
+          subscription
+        }),
+        now
+      );
+      await store.saveUserState(nextState);
+      return buildSubscriptionSnapshot(identity.userId, nextState, subscription);
+    },
+    async pauseSubscription({
+      request,
+      input,
+      platformContext
+    }) {
+      const identity = await resolveRequestIdentity({ request, platformContext });
+      const userState = await store.getUserState(identity.userId);
+      const subscriptionId = input.subscriptionId ?? userState?.subscriptionId;
+      if (!subscriptionId) {
+        throw new CreemHttpError(
+          400,
+          "No Creem subscription is linked to the current user yet."
+        );
+      }
+      const subscription = await creem.subscriptions.pause(subscriptionId);
+      const nextState = buildUserState(
+        userState,
+        buildSubscriptionStatePatch({
+          userState,
+          identity,
+          subscription
+        }),
+        now
+      );
+      await store.saveUserState(nextState);
+      return buildSubscriptionSnapshot(identity.userId, nextState, subscription);
+    },
+    async resumeSubscription({
+      request,
+      input,
+      platformContext
+    }) {
+      const identity = await resolveRequestIdentity({ request, platformContext });
+      const userState = await store.getUserState(identity.userId);
+      const subscriptionId = input.subscriptionId ?? userState?.subscriptionId;
+      if (!subscriptionId) {
+        throw new CreemHttpError(
+          400,
+          "No Creem subscription is linked to the current user yet."
+        );
+      }
+      const subscription = await creem.subscriptions.resume(subscriptionId);
+      const nextState = buildUserState(
+        userState,
+        buildSubscriptionStatePatch({
+          userState,
+          identity,
+          subscription
+        }),
+        now
+      );
+      await store.saveUserState(nextState);
+      return buildSubscriptionSnapshot(identity.userId, nextState, subscription);
+    },
+    async upgradeSubscription({
+      request,
+      input,
+      platformContext
+    }) {
+      const identity = await resolveRequestIdentity({ request, platformContext });
+      const userState = await store.getUserState(identity.userId);
+      const subscriptionId = input.subscriptionId ?? userState?.subscriptionId;
+      if (!subscriptionId) {
+        throw new CreemHttpError(
+          400,
+          "No Creem subscription is linked to the current user yet."
+        );
+      }
+      if (!input.productId) {
+        throw new CreemHttpError(400, "`productId` is required to upgrade.");
+      }
+      const subscription = await creem.subscriptions.upgrade(subscriptionId, {
+        productId: input.productId,
+        updateBehavior: input.updateBehavior
+      });
+      const nextState = buildUserState(
+        userState,
+        buildSubscriptionStatePatch({
+          userState,
+          identity,
+          subscription,
+          fallbackProductId: input.productId
+        }),
+        now
+      );
+      await store.saveUserState(nextState);
+      return buildSubscriptionSnapshot(identity.userId, nextState, subscription);
+    },
+    async createCustomerPortalLink({
+      request,
+      platformContext
+    }) {
+      const identity = await resolveRequestIdentity({ request, platformContext });
+      const userState = await store.getUserState(identity.userId);
+      const customerId = userState?.customerId ?? identity.customerId;
+      if (!customerId) {
+        throw new CreemHttpError(
+          400,
+          "No customer is linked to the current user yet. Complete a checkout first."
+        );
+      }
+      const portal = await creem.customers.generateBillingLinks({
+        customerId
+      });
+      return mapPortalEntity(portal, customerId);
+    },
+    async handleWebhook({
+      request,
+      rawBody,
+      signature,
+      platformContext
+    }) {
+      if (!verifyWebhookSignature(rawBody, signature, webhookSecret)) {
+        throw new CreemHttpError(401, "Invalid Creem webhook signature.");
+      }
+      const event = normalizeWebhookEvent(JSON.parse(rawBody));
+      if (await store.hasProcessedWebhook(event.id)) {
+        return {
+          ok: true,
+          duplicated: true,
+          eventId: event.id
+        };
+      }
+      const existingUserState = await resolveIdentityFromWebhook(store, event);
+      let resolvedUserState = existingUserState;
+      const checkoutId = extractId(event.object);
+      const existingCheckout = checkoutId ? await store.getCheckout(checkoutId) : null;
+      const eventMetadata = asOptionalJsonObject(event.object.metadata);
+      const subscriptionId = extractId(event.object.subscription);
+      const customerId = extractId(event.object.customer);
+      const orderId = extractId(event.object.order);
+      const productId = extractId(event.object.product);
+      const subscriptionStatus = typeof event.object.status === "string" ? event.object.status : null;
+      const userId = existingUserState?.userId ?? existingCheckout?.userId ?? (typeof asRecord(eventMetadata)[CREEM_USER_ID_KEY] === "string" ? asRecord(eventMetadata)[CREEM_USER_ID_KEY] : null);
+      if (userId) {
+        const nextState = buildUserState(
+          existingUserState,
+          {
+            userId,
+            email: extractCustomerEmail(event.object.customer) ?? existingUserState?.email ?? null,
+            customerId: customerId ?? existingUserState?.customerId ?? null,
+            subscriptionId: subscriptionId ?? existingUserState?.subscriptionId ?? null,
+            latestCheckoutId: checkoutId ?? existingUserState?.latestCheckoutId ?? null,
+            latestOrderId: orderId ?? existingUserState?.latestOrderId ?? null,
+            latestProductId: productId ?? existingUserState?.latestProductId ?? null,
+            subscriptionStatus,
+            entitlementActive: isEntitledFromStatus(subscriptionStatus),
+            metadata: eventMetadata ?? existingUserState?.metadata ?? null,
+            subscription: "collectionMethod" in event.object ? event.object : existingUserState?.subscription ?? null
+          },
+          now
+        );
+        await store.saveUserState(nextState);
+        resolvedUserState = nextState;
+        if (checkoutId) {
+          await store.saveCheckout({
+            checkoutId,
+            userId,
+            productId: productId ?? existingCheckout?.productId,
+            requestId: typeof event.object.request_id === "string" ? event.object.request_id : existingCheckout?.requestId,
+            status: typeof event.object.status === "string" ? event.object.status : existingCheckout?.status ?? "completed",
+            checkoutUrl: existingCheckout?.checkoutUrl ?? "",
+            successUrl: existingCheckout?.successUrl ?? null,
+            customerId: customerId ?? existingCheckout?.customerId ?? null,
+            subscriptionId: subscriptionId ?? existingCheckout?.subscriptionId ?? null,
+            orderId: orderId ?? existingCheckout?.orderId ?? null,
+            metadata: eventMetadata ?? existingCheckout?.metadata ?? null,
+            createdAt: existingCheckout?.createdAt ?? nowIso(now),
+            updatedAt: nowIso(now)
+          });
+        }
+      }
+      await dispatchWebhookHandlers({
+        request,
+        platformContext,
+        event,
+        userState: resolvedUserState
+      });
+      await store.markWebhookProcessed({
+        eventId: event.id,
+        eventType: event.eventType,
+        processedAt: nowIso(now)
+      });
+      return {
+        ok: true,
+        duplicated: false,
+        eventId: event.id
+      };
+    }
+  };
+};
+
+// src/server/fetchHandlers.ts
+var createCreemFetchHandlers = (options) => {
+  const core = createCreemServerCore(options);
+  const readOptionalJson = async (request) => {
+    const rawBody = await request.text();
+    return rawBody ? JSON.parse(rawBody) : {};
+  };
+  return {
+    async createCheckoutSession(request, platformContext) {
+      try {
+        const input = await request.json();
+        if (!input?.productId) {
+          throw new CreemHttpError(400, "`productId` is required.");
+        }
+        const session = await core.createCheckoutSession({
+          request,
+          platformContext,
+          input
+        });
+        return json(session, { status: 200 });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    },
+    async verifyCheckoutSession(request, platformContext) {
+      try {
+        const input = await readOptionalJson(request);
+        if (!input?.checkoutId) {
+          throw new CreemHttpError(400, "`checkoutId` is required.");
+        }
+        const verification = await core.verifyCheckoutSession({
+          request,
+          platformContext,
+          input
+        });
+        return json(verification, { status: 200 });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    },
+    async getSubscription(request, platformContext) {
+      try {
+        const snapshot = await core.getSubscriptionSnapshot({
+          request,
+          platformContext
+        });
+        return json(snapshot, { status: 200 });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    },
+    async cancelSubscription(request, platformContext) {
+      try {
+        const input = await readOptionalJson(request);
+        const snapshot = await core.cancelSubscription({
+          request,
+          platformContext,
+          input
+        });
+        return json(snapshot, { status: 200 });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    },
+    async pauseSubscription(request, platformContext) {
+      try {
+        const input = await readOptionalJson(request);
+        const snapshot = await core.pauseSubscription({
+          request,
+          platformContext,
+          input
+        });
+        return json(snapshot, { status: 200 });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    },
+    async resumeSubscription(request, platformContext) {
+      try {
+        const input = await readOptionalJson(request);
+        const snapshot = await core.resumeSubscription({
+          request,
+          platformContext,
+          input
+        });
+        return json(snapshot, { status: 200 });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    },
+    async upgradeSubscription(request, platformContext) {
+      try {
+        const input = await readOptionalJson(request);
+        const snapshot = await core.upgradeSubscription({
+          request,
+          platformContext,
+          input
+        });
+        return json(snapshot, { status: 200 });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    },
+    async createCustomerPortal(request, platformContext) {
+      try {
+        const portal = await core.createCustomerPortalLink({
+          request,
+          platformContext
+        });
+        return json(portal, { status: 200 });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    },
+    async handleWebhook(request, platformContext) {
+      try {
+        const signature = request.headers.get("creem-signature");
+        if (!signature) {
+          throw new CreemHttpError(401, "Missing Creem webhook signature.");
+        }
+        const rawBody = await request.text();
+        const result = await core.handleWebhook({
+          request,
+          platformContext,
+          rawBody,
+          signature
+        });
+        return json(result, { status: 200 });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    }
+  };
+};
+
+// src/server/express.ts
+var firstHeaderValue = (value) => value?.split(",")[0]?.trim();
+var getRequestOrigin = (request) => {
+  const protocol = firstHeaderValue(request.get("x-forwarded-proto")) ?? request.protocol;
+  const host = firstHeaderValue(request.get("x-forwarded-host")) ?? request.get("host") ?? "localhost";
+  return `${protocol}://${host}`;
+};
+var appendHeaders = (headers, source) => {
+  for (const [key, value] of Object.entries(source)) {
+    if (typeof value === "undefined") {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
+      }
+      continue;
+    }
+    headers.set(key, value);
+  }
+  return headers;
+};
+var serializeBody = (body) => {
+  if (typeof body === "undefined" || body === null) {
+    return void 0;
+  }
+  if (Buffer.isBuffer(body)) {
+    return new Uint8Array(body);
+  }
+  if (typeof body === "string") {
+    return body;
+  }
+  return JSON.stringify(body);
+};
+var toWebRequest = (request) => {
+  const origin = getRequestOrigin(request);
+  const url = new URL(request.originalUrl || request.url, origin);
+  const headers = appendHeaders(new Headers(), request.headers);
+  const init = {
+    method: request.method,
+    headers
+  };
+  if (!["GET", "HEAD"].includes(request.method.toUpperCase())) {
+    const body = serializeBody(request.body);
+    if (typeof body !== "undefined") {
+      init.body = body;
+    }
+  }
+  return new Request(url.toString(), init);
+};
+var sendWebResponse = async (response, webResponse) => {
+  response.status(webResponse.status);
+  webResponse.headers.forEach((value, key) => {
+    if (key.toLowerCase() === "transfer-encoding") {
+      return;
+    }
+    response.setHeader(key, value);
+  });
+  response.send(await webResponse.text());
+};
+var __internal = {
+  firstHeaderValue,
+  getRequestOrigin,
+  appendHeaders,
+  serializeBody,
+  toWebRequest,
+  sendWebResponse
+};
+var createCreemExpressRouter = ({
+  getPlatformContext,
+  ...options
+}) => {
+  const router = Router();
+  const handlers = createCreemFetchHandlers(options);
+  const runHandler = (handler) => {
+    return async (request, response) => {
+      const webRequest = toWebRequest(request);
+      const platformContext = getPlatformContext ? getPlatformContext(request, response) : request;
+      const webResponse = await handler(webRequest, platformContext);
+      await sendWebResponse(response, webResponse);
+    };
+  };
+  router.post(
+    "/creem/checkout-sessions",
+    express.json(),
+    runHandler(handlers.createCheckoutSession)
+  );
+  router.post(
+    "/creem/checkout/verify",
+    express.json(),
+    runHandler(handlers.verifyCheckoutSession)
+  );
+  router.get("/creem/subscription", runHandler(handlers.getSubscription));
+  router.post(
+    "/creem/subscription/cancel",
+    express.json(),
+    runHandler(handlers.cancelSubscription)
+  );
+  router.post(
+    "/creem/subscription/pause",
+    express.json(),
+    runHandler(handlers.pauseSubscription)
+  );
+  router.post(
+    "/creem/subscription/resume",
+    express.json(),
+    runHandler(handlers.resumeSubscription)
+  );
+  router.post(
+    "/creem/subscription/upgrade",
+    express.json(),
+    runHandler(handlers.upgradeSubscription)
+  );
+  router.post(
+    "/creem/customer-portal",
+    express.json(),
+    runHandler(handlers.createCustomerPortal)
+  );
+  router.post(
+    "/creem/webhooks",
+    express.raw({
+      type: "*/*"
+    }),
+    runHandler(handlers.handleWebhook)
+  );
+  return router;
+};
+var createCreemRouter = createCreemExpressRouter;
+
+export {
+  verifyWebhookSignature,
+  createCreemServerCore,
+  createCreemFetchHandlers,
+  __internal,
+  createCreemExpressRouter,
+  createCreemRouter
+};