@lunora/payment 1.0.0-alpha.7 → 1.0.0-alpha.71

package/dist/packem_shared/createDatabasePaymentStore-bYB_HUE6.mjs

@@ -1,172 +0,0 @@
-import { money } from './addMoney-bCcs1nyw.mjs';
-
-const readString = (row, key) => typeof row[key] === "string" ? row[key] : "";
-const readOptionalString = (row, key) => typeof row[key] === "string" ? row[key] : void 0;
-const readNumber = (row, key) => typeof row[key] === "number" ? row[key] : 0;
-const readOptionalNumber = (row, key) => typeof row[key] === "number" ? row[key] : void 0;
-const readBoolean = (row, key) => row[key] === true;
-const readBigint = (row, key) => {
-  const value = row[key];
-  if (typeof value === "bigint") {
-    return value;
-  }
-  return typeof value === "number" || typeof value === "string" ? BigInt(value) : 0n;
-};
-const customerToRow = (customer) => {
-  return {
-    createdAt: customer.createdAt,
-    email: customer.email,
-    provider: customer.provider,
-    providerCustomerId: customer.id,
-    referenceId: customer.referenceId
-  };
-};
-const rowToCustomer = (row) => {
-  return {
-    createdAt: readNumber(row, "createdAt"),
-    email: readOptionalString(row, "email"),
-    id: readString(row, "providerCustomerId"),
-    provider: readString(row, "provider"),
-    referenceId: readString(row, "referenceId")
-  };
-};
-const sessionToRow = (session) => {
-  return {
-    amountMinor: session.amount.minorUnits,
-    capturedMinor: session.capturedAmount.minorUnits,
-    createdAt: session.createdAt,
-    currency: session.amount.currency,
-    provider: session.provider,
-    providerSessionId: session.id,
-    referenceId: session.referenceId,
-    refundedMinor: session.refundedAmount.minorUnits,
-    state: session.state,
-    updatedAt: session.updatedAt
-  };
-};
-const rowToSession = (row) => {
-  const currency = readString(row, "currency");
-  return {
-    amount: money(readBigint(row, "amountMinor"), currency),
-    capturedAmount: money(readBigint(row, "capturedMinor"), currency),
-    createdAt: readNumber(row, "createdAt"),
-    id: readString(row, "providerSessionId"),
-    provider: readString(row, "provider"),
-    referenceId: readString(row, "referenceId"),
-    refundedAmount: money(readBigint(row, "refundedMinor"), currency),
-    state: readString(row, "state"),
-    updatedAt: readNumber(row, "updatedAt")
-  };
-};
-const subscriptionToRow = (subscription) => {
-  return {
-    cancelAtPeriodEnd: subscription.cancelAtPeriodEnd,
-    createdAt: subscription.createdAt,
-    currentPeriodEnd: subscription.currentPeriodEnd,
-    currentPeriodStart: subscription.currentPeriodStart,
-    priceId: subscription.priceId,
-    provider: subscription.provider,
-    providerSubscriptionId: subscription.id,
-    quantity: subscription.quantity,
-    referenceId: subscription.referenceId,
-    state: subscription.state,
-    updatedAt: subscription.updatedAt
-  };
-};
-const rowToSubscription = (row) => {
-  return {
-    cancelAtPeriodEnd: readBoolean(row, "cancelAtPeriodEnd"),
-    createdAt: readNumber(row, "createdAt"),
-    currentPeriodEnd: readOptionalNumber(row, "currentPeriodEnd"),
-    currentPeriodStart: readOptionalNumber(row, "currentPeriodStart"),
-    id: readString(row, "providerSubscriptionId"),
-    priceId: readString(row, "priceId"),
-    provider: readString(row, "provider"),
-    quantity: readNumber(row, "quantity"),
-    referenceId: readString(row, "referenceId"),
-    state: readString(row, "state"),
-    updatedAt: readNumber(row, "updatedAt")
-  };
-};
-const usageEventToRow = (event) => {
-  return {
-    createdAt: event.createdAt,
-    featureId: event.featureId,
-    idempotencyKey: event.idempotencyKey,
-    provider: event.provider,
-    quantity: event.quantity,
-    referenceId: event.referenceId,
-    reportedToProvider: event.reportedToProvider
-  };
-};
-const createDatabasePaymentStore = (database) => {
-  const upsert = async (table, where, row) => {
-    const existing = await database.findFirst(table, where);
-    if (existing) {
-      await database.patch(existing._id, row);
-      return;
-    }
-    await database.insert(table, row);
-  };
-  return {
-    getCustomerByReference: async (provider, referenceId) => {
-      const row = await database.findFirst("customers", { provider, referenceId });
-      return row ? rowToCustomer(row) : void 0;
-    },
-    getPaymentSession: async (provider, id) => {
-      const row = await database.findFirst("paymentSessions", { provider, providerSessionId: id });
-      return row ? rowToSession(row) : void 0;
-    },
-    getSubscription: async (provider, id) => {
-      const row = await database.findFirst("subscriptions", { provider, providerSubscriptionId: id });
-      return row ? rowToSubscription(row) : void 0;
-    },
-    listSubscriptionsByReference: async (referenceId) => {
-      const rows = await database.findMany("subscriptions", { referenceId });
-      return rows.map((row) => rowToSubscription(row));
-    },
-    markEventProcessed: async (provider, eventId) => {
-      const existing = await database.findFirst("events", { provider, providerEventId: eventId });
-      if (existing) {
-        return false;
-      }
-      await database.insert("events", { processedAt: Date.now(), provider, providerEventId: eventId, type: "" });
-      return true;
-    },
-    releaseEvent: async (provider, eventId) => {
-      const existing = await database.findFirst("events", { provider, providerEventId: eventId });
-      if (existing) {
-        await database.delete(existing._id);
-      }
-    },
-    markUsageReported: async (provider, idempotencyKey) => {
-      const existing = await database.findFirst("usageEvents", { idempotencyKey, provider });
-      if (existing) {
-        await database.patch(existing._id, { reportedToProvider: true });
-      }
-    },
-    recordUsage: async (event) => {
-      const existing = await database.findFirst("usageEvents", { idempotencyKey: event.idempotencyKey, provider: event.provider });
-      if (existing) {
-        return false;
-      }
-      await database.insert("usageEvents", usageEventToRow(event));
-      return true;
-    },
-    sumUsage: async (referenceId, featureId, since) => {
-      const rows = await database.findMany("usageEvents", { featureId, referenceId });
-      let total = 0;
-      for (const row of rows) {
-        if (readNumber(row, "createdAt") >= since) {
-          total += readNumber(row, "quantity");
-        }
-      }
-      return total;
-    },
-    upsertCustomer: async (customer) => upsert("customers", { provider: customer.provider, providerCustomerId: customer.id }, customerToRow(customer)),
-    upsertPaymentSession: async (session) => upsert("paymentSessions", { provider: session.provider, providerSessionId: session.id }, sessionToRow(session)),
-    upsertSubscription: async (subscription) => upsert("subscriptions", { provider: subscription.provider, providerSubscriptionId: subscription.id }, subscriptionToRow(subscription))
-  };
-};
-
-export { createDatabasePaymentStore };

package/dist/packem_shared/createPayment-BccfPGyw.mjs

@@ -1,190 +0,0 @@
-import { usagePeriodStart, resolveEntitlements, featureNames, hasActivePrice } from './entitlementsForReference-CzZGXPoZ.mjs';
-import { LunoraPaymentError } from './LunoraPaymentError-B3hEzXSs.mjs';
-import idempotencyKey from './idempotencyKey-BFzDCA7g.mjs';
-import { n as notifyObserver } from './observability-CvhJ205g.mjs';
-import applyWebhookAction from './applyWebhookAction-DpAqf3Lw.mjs';
-
-const jsonResponse = (body, status) => Response.json(body, { headers: { "content-type": "application/json" }, status });
-const stripReferenceId = (metadata) => metadata && "referenceId" in metadata ? Object.fromEntries(Object.entries(metadata).filter(([key]) => key !== "referenceId")) : metadata;
-const createPayment = (options) => {
-  const { adapter, store } = options;
-  const ensureAuthorized = async (referenceId) => {
-    if (!options.authorize) {
-      return;
-    }
-    let allowed;
-    try {
-      allowed = await options.authorize(referenceId);
-    } catch {
-      throw new LunoraPaymentError("FORBIDDEN", `caller not authorized for reference "${referenceId}"`);
-    }
-    if (!allowed) {
-      throw new LunoraPaymentError("FORBIDDEN", `caller not authorized for reference "${referenceId}"`);
-    }
-  };
-  const startCheckout = async (input) => {
-    await ensureAuthorized(input.referenceId);
-    const metadata = stripReferenceId(input.metadata);
-    let { customerId } = input;
-    if (!customerId) {
-      const existing = await store.getCustomerByReference(adapter.identifier, input.referenceId);
-      if (existing) {
-        customerId = existing.id;
-      } else {
-        const customer = await adapter.getOrCreateCustomer({ referenceId: input.referenceId });
-        customerId = customer.id;
-        await store.upsertCustomer(customer);
-      }
-    }
-    const key = input.idempotencyKey ?? idempotencyKey(
-      "checkout",
-      adapter.identifier,
-      input.referenceId,
-      input.priceId,
-      input.mode,
-      String(input.quantity ?? 1),
-      input.successUrl,
-      input.cancelUrl,
-      metadata ? JSON.stringify(metadata) : ""
-    );
-    return adapter.createCheckout({ ...input, customerId, idempotencyKey: key, metadata });
-  };
-  const evaluateFeature = async (entitlements, subscriptions, referenceId, featureId, need) => {
-    const limit = entitlements.limit(featureId);
-    if (limit !== void 0) {
-      const used = await store.sumUsage(referenceId, featureId, usagePeriodStart(subscriptions));
-      const balance = limit - used;
-      return { allowed: balance >= need, balance, limit, unlimited: false, used };
-    }
-    return { allowed: entitlements.has(featureId), unlimited: entitlements.has(featureId) };
-  };
-  return {
-    adapter,
-    attach: async (input) => startCheckout({ ...input, mode: input.mode ?? "subscription" }),
-    cancelSubscription: async (subscriptionId, cancelOptions) => {
-      const existing = await store.getSubscription(adapter.identifier, subscriptionId);
-      if (!existing) {
-        throw new LunoraPaymentError("NOT_FOUND", `subscription "${subscriptionId}" not found`);
-      }
-      try {
-        await ensureAuthorized(existing.referenceId);
-      } catch {
-        throw new LunoraPaymentError("NOT_FOUND", `subscription "${subscriptionId}" not found`);
-      }
-      const key = cancelOptions?.idempotencyKey ?? idempotencyKey("cancel_subscription", adapter.identifier, subscriptionId);
-      const updated = await adapter.cancelSubscription(subscriptionId, { ...cancelOptions, idempotencyKey: key });
-      await store.upsertSubscription(updated);
-      return updated;
-    },
-    check: async (input) => {
-      await ensureAuthorized(input.referenceId);
-      const subscriptions = await store.listSubscriptionsByReference(input.referenceId);
-      if (input.priceId !== void 0) {
-        return { allowed: hasActivePrice(subscriptions, input.priceId), unlimited: false };
-      }
-      if (input.featureId === void 0) {
-        throw new LunoraPaymentError("CONFIG_INVALID", "check() requires a featureId or priceId");
-      }
-      if (!options.entitlements) {
-        throw new LunoraPaymentError("CONFIG_INVALID", "check() requires `entitlements` to be configured");
-      }
-      const entitlements = resolveEntitlements(options.entitlements, subscriptions);
-      return evaluateFeature(entitlements, subscriptions, input.referenceId, input.featureId, input.quantity ?? 1);
-    },
-    createCheckout: async (input) => startCheckout(input),
-    createPortalSession: async (referenceId, returnUrl) => {
-      await ensureAuthorized(referenceId);
-      const customer = await store.getCustomerByReference(adapter.identifier, referenceId);
-      if (!customer) {
-        throw new LunoraPaymentError("NOT_FOUND", `no customer for reference "${referenceId}"`);
-      }
-      return adapter.createPortalSession({ customerId: customer.id, returnUrl });
-    },
-    handleWebhook: async (request) => {
-      let action;
-      try {
-        const payload = await request.text();
-        action = await adapter.parseWebhook({ headers: request.headers, payload });
-      } catch (error) {
-        if (error instanceof LunoraPaymentError) {
-          return jsonResponse({ error: error.message }, error.status);
-        }
-        return jsonResponse({ error: "webhook error" }, 400);
-      }
-      const result = await applyWebhookAction(store, action, options.observability);
-      return jsonResponse({ applied: result.applied, reason: result.reason }, 200);
-    },
-    listBalances: async (referenceId) => {
-      await ensureAuthorized(referenceId);
-      if (!options.entitlements) {
-        throw new LunoraPaymentError("CONFIG_INVALID", "listBalances() requires `entitlements` to be configured");
-      }
-      const subscriptions = await store.listSubscriptionsByReference(referenceId);
-      const entitlements = resolveEntitlements(options.entitlements, subscriptions);
-      return Promise.all(
-        featureNames(options.entitlements).map(async (featureId) => {
-          return {
-            featureId,
-            ...await evaluateFeature(entitlements, subscriptions, referenceId, featureId, 1)
-          };
-        })
-      );
-    },
-    listSubscriptions: async (referenceId) => {
-      await ensureAuthorized(referenceId);
-      return store.listSubscriptionsByReference(referenceId);
-    },
-    store,
-    track: async (input) => {
-      await ensureAuthorized(input.referenceId);
-      const target = input.quantity ?? 1;
-      const key = input.idempotencyKey ?? crypto.randomUUID();
-      let delta = target;
-      if (input.mode === "set") {
-        const subscriptions = await store.listSubscriptionsByReference(input.referenceId);
-        const current = await store.sumUsage(input.referenceId, input.featureId, usagePeriodStart(subscriptions));
-        delta = target - current;
-      }
-      if (delta === 0) {
-        return { recorded: false, reportedToProvider: false };
-      }
-      const recorded = await store.recordUsage({
-        createdAt: Date.now(),
-        featureId: input.featureId,
-        idempotencyKey: key,
-        provider: adapter.identifier,
-        quantity: delta,
-        referenceId: input.referenceId,
-        reportedToProvider: false
-      });
-      if (!recorded) {
-        return { recorded: false, reportedToProvider: false };
-      }
-      if (delta <= 0 || !adapter.capabilities.usageMetering || !adapter.reportUsage) {
-        return { recorded: true, reportedToProvider: false };
-      }
-      try {
-        const customer = await store.getCustomerByReference(adapter.identifier, input.referenceId);
-        await adapter.reportUsage({
-          customerId: customer?.id,
-          featureId: input.featureId,
-          idempotencyKey: key,
-          quantity: delta,
-          referenceId: input.referenceId
-        });
-        await store.markUsageReported(adapter.identifier, key);
-        return { recorded: true, reportedToProvider: true };
-      } catch {
-        notifyObserver(options.observability, {
-          featureId: input.featureId,
-          provider: adapter.identifier,
-          referenceId: input.referenceId,
-          type: "usage.report_failed"
-        });
-        return { recorded: true, reportedToProvider: false };
-      }
-    }
-  };
-};
-
-export { createPayment };

package/dist/packem_shared/createPolarAdapter-BJtVGSlF.mjs

@@ -1,217 +0,0 @@
-import { LunoraPaymentError } from './LunoraPaymentError-B3hEzXSs.mjs';
-import { a as asRecord, r as readString, b as readBoolean, c as readNumber } from './json-Db337f36.mjs';
-import { money, zeroMoney } from './addMoney-bCcs1nyw.mjs';
-import { verifyStandardWebhook } from './constantTimeEqual-CfY0jYcL.mjs';
-
-const PAYMENT_STATE_BY_POLAR_ORDER_STATUS = {
-  paid: "captured",
-  partially_refunded: "partially_refunded",
-  pending: "initiated",
-  refunded: "refunded"
-};
-const SUBSCRIPTION_STATE_BY_POLAR_STATUS = {
-  active: "active",
-  canceled: "canceled",
-  incomplete: "trialing",
-  incomplete_expired: "canceled",
-  past_due: "past_due",
-  trialing: "trialing",
-  unpaid: "past_due"
-};
-const notSupported = (operation) => {
-  throw new LunoraPaymentError("PROVIDER_ERROR", `polar (merchant-of-record) does not support ${operation}`);
-};
-const parseTimestamp = (value) => {
-  const parsed = typeof value === "string" ? Date.parse(value) : Number.NaN;
-  return Number.isNaN(parsed) ? void 0 : parsed;
-};
-const subscriptionFromPolar = (subscription) => {
-  const now = Date.now();
-  return {
-    cancelAtPeriodEnd: subscription.cancelAtPeriodEnd ?? false,
-    createdAt: now,
-    currentPeriodEnd: parseTimestamp(subscription.currentPeriodEnd),
-    currentPeriodStart: parseTimestamp(subscription.currentPeriodStart),
-    id: subscription.id,
-    priceId: subscription.productId ?? "",
-    provider: "polar",
-    quantity: 1,
-    referenceId: subscription.metadata?.referenceId ?? "",
-    state: SUBSCRIPTION_STATE_BY_POLAR_STATUS[subscription.status] ?? "active",
-    updatedAt: now
-  };
-};
-const orderToSession = (order) => {
-  const now = Date.now();
-  const currency = order.currency ?? "usd";
-  const amount = money(BigInt(order.totalAmount ?? order.amount ?? 0), currency);
-  const state = PAYMENT_STATE_BY_POLAR_ORDER_STATUS[order.status] ?? "initiated";
-  const settled = state === "captured" || state === "partially_refunded" || state === "refunded";
-  return {
-    amount,
-    capturedAmount: settled ? amount : zeroMoney(currency),
-    createdAt: now,
-    id: order.id,
-    provider: "polar",
-    referenceId: "",
-    refundedAmount: state === "refunded" ? amount : zeroMoney(currency),
-    state,
-    updatedAt: now
-  };
-};
-const subscriptionEventType = (status) => {
-  const state = status ? SUBSCRIPTION_STATE_BY_POLAR_STATUS[status] : void 0;
-  if (state === "canceled") {
-    return "subscription.canceled";
-  }
-  if (state === "past_due") {
-    return "subscription.past_due";
-  }
-  if (state === "active" || state === "trialing") {
-    return "subscription.active";
-  }
-  return "subscription.updated";
-};
-const referenceFromMetadata = (object) => readString(asRecord(object.metadata), "referenceId");
-const mapEvent = (eventId, eventType, object) => {
-  const base = { eventId, provider: "polar", raw: { object, type: eventType } };
-  const currency = readString(object, "currency") ?? "usd";
-  switch (eventType) {
-    case "order.created":
-    case "order.paid": {
-      return {
-        ...base,
-        amount: money(BigInt(readNumber(object, "total_amount") ?? readNumber(object, "amount") ?? 0), currency),
-        customerId: readString(object, "customer_id"),
-        referenceId: referenceFromMetadata(object),
-        sessionId: readString(object, "id"),
-        subscriptionId: readString(object, "subscription_id"),
-        type: "payment.captured"
-      };
-    }
-    case "refund.created": {
-      return {
-        ...base,
-        amount: money(BigInt(readNumber(object, "amount") ?? 0), currency),
-        referenceId: referenceFromMetadata(object),
-        sessionId: readString(object, "order_id") ?? readString(object, "id"),
-        type: "payment.refunded"
-      };
-    }
-    case "subscription.active":
-    case "subscription.canceled":
-    case "subscription.created":
-    case "subscription.revoked":
-    case "subscription.updated": {
-      const type = eventType === "subscription.revoked" ? "subscription.canceled" : subscriptionEventType(readString(object, "status"));
-      return {
-        ...base,
-        cancelAtPeriodEnd: readBoolean(object, "cancel_at_period_end"),
-        currentPeriodEnd: parseTimestamp(readString(object, "current_period_end")),
-        currentPeriodStart: parseTimestamp(readString(object, "current_period_start")),
-        customerId: readString(object, "customer_id"),
-        priceId: readString(object, "product_id"),
-        referenceId: referenceFromMetadata(object),
-        subscriptionId: readString(object, "id"),
-        type
-      };
-    }
-    default: {
-      return { ...base, type: "unhandled" };
-    }
-  }
-};
-const createPolarAdapter = (options) => {
-  const { client, webhookSecret } = options;
-  return {
-    cancelPayment: () => notSupported("manual payment cancellation"),
-    cancelSubscription: async (subscriptionId, cancelOptions) => {
-      const subscription = cancelOptions?.atPeriodEnd ? await client.subscriptions.update({ id: subscriptionId, subscriptionUpdate: { cancelAtPeriodEnd: true } }) : await client.subscriptions.revoke({ id: subscriptionId });
-      return subscriptionFromPolar(subscription);
-    },
-    capabilities: { merchantOfRecord: true, portal: true, usageMetering: true },
-    capturePayment: (_input) => notSupported("manual capture"),
-    createCheckout: async (input) => {
-      const checkout = await client.checkouts.create({
-        customerEmail: void 0,
-        // Pin the framework-controlled `referenceId` LAST so caller metadata can never override it.
-        metadata: { ...input.metadata, referenceId: input.referenceId },
-        products: [input.priceId],
-        successUrl: input.successUrl
-      });
-      return { id: checkout.id, provider: "polar", url: checkout.url };
-    },
-    createPortalSession: async (input) => {
-      const session = await client.customerSessions.create({ customerId: input.customerId });
-      return { url: session.customerPortalUrl };
-    },
-    getOrCreateCustomer: async (ref) => {
-      const customer = await client.customers.create({
-        email: ref.email,
-        externalId: ref.referenceId,
-        metadata: { ...ref.metadata, referenceId: ref.referenceId }
-      });
-      return { createdAt: Date.now(), email: customer.email ?? void 0, id: customer.id, provider: "polar", referenceId: ref.referenceId };
-    },
-    getPaymentStatus: async (sessionId) => orderToSession(await client.orders.get({ id: sessionId })),
-    getSubscriptionStatus: async (subscriptionId) => subscriptionFromPolar(await client.subscriptions.get({ id: subscriptionId })),
-    identifier: "polar",
-    parseWebhook: async ({ headers, payload }) => {
-      const webhookId = headers.get("webhook-id") ?? "";
-      await verifyStandardWebhook({
-        payload,
-        secret: webhookSecret,
-        toleranceSeconds: options.webhookToleranceSeconds,
-        webhookId,
-        webhookSignature: headers.get("webhook-signature") ?? "",
-        webhookTimestamp: headers.get("webhook-timestamp") ?? ""
-      });
-      const event = asRecord(JSON.parse(payload));
-      return mapEvent(webhookId, readString(event, "type") ?? "", asRecord(event.data));
-    },
-    refundPayment: async (input) => {
-      await client.refunds.create({
-        amount: input.amount ? Number(input.amount.minorUnits) : void 0,
-        orderId: input.sessionId,
-        reason: input.reason ?? "customer_request"
-      });
-      const refundedAmount = input.amount ?? money(0, "usd");
-      return {
-        amount: refundedAmount,
-        capturedAmount: refundedAmount,
-        createdAt: Date.now(),
-        id: input.sessionId,
-        provider: "polar",
-        referenceId: "",
-        refundedAmount,
-        state: "refunded",
-        updatedAt: Date.now()
-      };
-    },
-    reportUsage: async (input) => {
-      await client.events.ingest({
-        events: [
-          {
-            externalCustomerId: input.referenceId,
-            metadata: { value: input.quantity },
-            name: input.featureId,
-            timestamp: input.timestamp === void 0 ? void 0 : new Date(input.timestamp).toISOString()
-          }
-        ]
-      });
-    },
-    resumeSubscription: async (subscriptionId) => {
-      const subscription = await client.subscriptions.update({ id: subscriptionId, subscriptionUpdate: { cancelAtPeriodEnd: false } });
-      return subscriptionFromPolar(subscription);
-    },
-    updateSubscription: async (subscriptionId, patch) => {
-      const subscription = await client.subscriptions.update({
-        id: subscriptionId,
-        subscriptionUpdate: patch.priceId ? { productId: patch.priceId } : {}
-      });
-      return subscriptionFromPolar(subscription);
-    }
-  };
-};
-
-export { createPolarAdapter };