@lunora/payment 1.0.0-alpha.30 → 1.0.0-alpha.32

package/dist/packem_shared/createPayment-CKQAznOL.mjs

@@ -1,200 +0,0 @@
-import { toErrorBody } from '@lunora/errors';
-import { usagePeriodStart, resolveEntitlements, featureNames, hasActivePrice } from './entitlementsForReference-CzZGXPoZ.mjs';
-import { LunoraPaymentError } from './LunoraPaymentError-BeQlhkZj.mjs';
-import { idempotencyKey, derivedIdempotencyKey } from './idempotencyKey-BzaHGdHD.mjs';
-import { n as notifyObserver } from './observability-CvhJ205g.mjs';
-import applyWebhookAction from './applyWebhookAction-CLAx4svt.mjs';
-
-const jsonResponse = (body, status = 200, headers) => Response.json(body, { headers: { "content-type": "application/json", ...headers }, 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;
-    const existing = await store.getCustomerByReference(adapter.identifier, input.referenceId);
-    if (existing) {
-      customerId = existing.id;
-    } else {
-      const customer = await adapter.getOrCreateCustomer({ email: input.email, referenceId: input.referenceId });
-      customerId = customer.id;
-      await store.upsertCustomer(customer);
-    }
-    const key = input.idempotencyKey ?? await derivedIdempotencyKey(
-      "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);
-      if (input.featureId === void 0 && input.priceId === void 0) {
-        throw new LunoraPaymentError("CONFIG_INVALID", "check() requires a featureId or priceId");
-      }
-      if (adapter.checkEntitlement) {
-        return adapter.checkEntitlement(input);
-      }
-      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) {
-          const { body, status } = toErrorBody(error);
-          return jsonResponse({ error: body.message }, 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 (adapter.getBalances) {
-        return adapter.getBalances(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/entitlementsForReference-CzZGXPoZ.mjs

@@ -1,51 +0,0 @@
-const ACTIVE_STATES = /* @__PURE__ */ new Set(["active", "trialing"]);
-const usagePeriodStart = (subscriptions) => {
-  let start = 0;
-  for (const subscription of subscriptions) {
-    if (ACTIVE_STATES.has(subscription.state) && subscription.currentPeriodStart !== void 0) {
-      start = Math.max(start, subscription.currentPeriodStart);
-    }
-  }
-  return start;
-};
-const featureNames = (config) => {
-  const names = /* @__PURE__ */ new Set();
-  for (const plan of Object.values(config.plans)) {
-    for (const feature of plan.features ?? []) {
-      names.add(feature);
-    }
-    for (const key of Object.keys(plan.limits ?? {})) {
-      names.add(key);
-    }
-  }
-  return [...names].toSorted((a, b) => a.localeCompare(b));
-};
-const hasActivePrice = (subscriptions, priceId) => subscriptions.some((subscription) => subscription.priceId === priceId && ACTIVE_STATES.has(subscription.state));
-const resolveEntitlements = (config, subscriptions) => {
-  const activePriceIds = new Set(subscriptions.filter((subscription) => ACTIVE_STATES.has(subscription.state)).map((subscription) => subscription.priceId));
-  const plans = [];
-  const features = /* @__PURE__ */ new Set();
-  const limits = /* @__PURE__ */ new Map();
-  for (const [name, plan] of Object.entries(config.plans)) {
-    if (!plan.priceIds.some((id) => activePriceIds.has(id))) {
-      continue;
-    }
-    plans.push(name);
-    for (const feature of plan.features ?? []) {
-      features.add(feature);
-    }
-    for (const [key, value] of Object.entries(plan.limits ?? {})) {
-      const current = limits.get(key);
-      limits.set(key, current === void 0 ? value : Math.max(current, value));
-    }
-  }
-  return {
-    features,
-    has: (feature) => features.has(feature),
-    limit: (key) => limits.get(key),
-    plans
-  };
-};
-const entitlementsForReference = async (store, config, referenceId) => resolveEntitlements(config, await store.listSubscriptionsByReference(referenceId));
-
-export { entitlementsForReference, featureNames, hasActivePrice, resolveEntitlements, usagePeriodStart };

package/dist/packem_shared/idempotencyKey-BzaHGdHD.mjs

@@ -1,9 +0,0 @@
-const encoder = new TextEncoder();
-const sha256Hex = async (value) => [...new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(value)))].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-const idempotencyKey = (operation, ...parts) => [operation, ...parts.map(String)].join(":");
-const derivedIdempotencyKey = async (operation, provider, ...parts) => {
-  const digest = await sha256Hex(JSON.stringify([provider, ...parts.map(String)]));
-  return `${operation}:${provider}:${digest}`;
-};
-
-export { derivedIdempotencyKey, idempotencyKey };

package/dist/packem_shared/json-D0Cb5aMv.mjs

@@ -1,29 +0,0 @@
-const asRecord = (value) => typeof value === "object" && value !== null ? value : {};
-const readString = (object, key) => typeof object[key] === "string" ? object[key] : void 0;
-const readNumber = (object, key) => typeof object[key] === "number" ? object[key] : void 0;
-const readBoolean = (object, key) => typeof object[key] === "boolean" ? object[key] : void 0;
-const readAny = (object, ...keys) => {
-  for (const key of keys) {
-    const value = readString(object, key);
-    if (value !== void 0) {
-      return value;
-    }
-  }
-  return void 0;
-};
-const readAnyNumber = (object, ...keys) => {
-  for (const key of keys) {
-    const value = readNumber(object, key);
-    if (value !== void 0) {
-      return value;
-    }
-  }
-  return void 0;
-};
-const referenceFromMetadata = (object) => readString(asRecord(object.metadata), "referenceId");
-const parseTimestamp = (value) => {
-  const parsed = typeof value === "string" ? Date.parse(value) : Number.NaN;
-  return Number.isNaN(parsed) ? void 0 : parsed;
-};
-
-export { asRecord as a, readNumber as b, readAny as c, readAnyNumber as d, readBoolean as e, referenceFromMetadata as f, parseTimestamp as p, readString as r };

package/dist/packem_shared/lunoraDatabaseToPaymentDatabase-DTsgPvfO.mjs

@@ -1,29 +0,0 @@
-import { createPayment } from './createPayment-CKQAznOL.mjs';
-import { createDatabasePaymentStore } from './createDatabasePaymentStore-C0NUCj1H.mjs';
-
-const lunoraDatabaseToPaymentDatabase = (database) => {
-  return {
-    delete: async (id) => database.delete(id),
-    findFirst: async (table, where) => await database.findFirst(table, { where }),
-    findMany: async (table, where) => {
-      const result = await database.findMany(table, { where });
-      return result.page;
-    },
-    insert: async (table, document) => database.insert(table, document),
-    patch: async (id, patch) => database.patch(id, patch)
-  };
-};
-const paymentsFromContext = (context, options) => {
-  const userId = context.auth?.userId ?? void 0;
-  return createPayment({
-    adapter: options.adapter,
-    // The default authorizer fails closed on an empty/whitespace reference: a missing identity or a
-    // blank reference (e.g. webhook-orphaned rows with `referenceId: ""`) is never authorized.
-    authorize: options.authorize ?? ((referenceId) => referenceId.trim() !== "" && userId !== void 0 && referenceId === userId),
-    entitlements: options.entitlements,
-    observability: options.observability,
-    store: createDatabasePaymentStore(lunoraDatabaseToPaymentDatabase(context.db))
-  });
-};
-
-export { lunoraDatabaseToPaymentDatabase, paymentsFromContext };

package/dist/packem_shared/not-supported-C0onRyia.mjs

@@ -1,7 +0,0 @@
-import { LunoraPaymentError } from './LunoraPaymentError-BeQlhkZj.mjs';
-
-const makeNotSupported = (label) => (operation) => {
-  throw new LunoraPaymentError("PROVIDER_ERROR", `${label} does not support ${operation}`);
-};
-
-export { makeNotSupported as m };

package/dist/packem_shared/observability-CvhJ205g.mjs

@@ -1,11 +0,0 @@
-const notifyObserver = (observer, event) => {
-  if (!observer) {
-    return;
-  }
-  try {
-    observer(event);
-  } catch {
-  }
-};
-
-export { notifyObserver as n };

package/dist/packem_shared/paymentTables-D4TbhaIk.mjs

@@ -1,59 +0,0 @@
-import { defineTable } from '@lunora/server';
-import { v } from '@lunora/values';
-
-const customers = defineTable({
-  createdAt: v.number(),
-  email: v.optional(v.string()),
-  provider: v.string(),
-  providerCustomerId: v.string(),
-  referenceId: v.string()
-}).index("by_provider_customer", ["provider", "providerCustomerId"], { unique: true }).index("by_reference", ["referenceId"]);
-const subscriptions = defineTable({
-  cancelAtPeriodEnd: v.boolean(),
-  createdAt: v.number(),
-  currentPeriodEnd: v.optional(v.number()),
-  currentPeriodStart: v.optional(v.number()),
-  priceId: v.string(),
-  provider: v.string(),
-  providerSubscriptionId: v.string(),
-  quantity: v.number(),
-  referenceId: v.string(),
-  state: v.string(),
-  updatedAt: v.number()
-}).index("by_provider_subscription", ["provider", "providerSubscriptionId"], { unique: true }).index("by_reference", ["referenceId"]);
-const paymentSessions = defineTable({
-  amountMinor: v.bigint(),
-  capturedMinor: v.bigint(),
-  createdAt: v.number(),
-  currency: v.string(),
-  provider: v.string(),
-  providerSessionId: v.string(),
-  referenceId: v.string(),
-  refundedMinor: v.bigint(),
-  state: v.string(),
-  updatedAt: v.number()
-}).index("by_provider_session", ["provider", "providerSessionId"], { unique: true }).index("by_reference", ["referenceId"]);
-const events = defineTable({
-  processedAt: v.number(),
-  provider: v.string(),
-  providerEventId: v.string(),
-  type: v.string()
-}).index("by_provider_event", ["provider", "providerEventId"], { unique: true });
-const usageEvents = defineTable({
-  createdAt: v.number(),
-  featureId: v.string(),
-  idempotencyKey: v.string(),
-  provider: v.string(),
-  quantity: v.number(),
-  referenceId: v.string(),
-  reportedToProvider: v.boolean()
-}).index("by_idempotency", ["provider", "idempotencyKey"], { unique: true }).index("by_reference_feature", ["referenceId", "featureId"]);
-const paymentTables = {
-  customers,
-  events,
-  paymentSessions,
-  subscriptions,
-  usageEvents
-};
-
-export { paymentTables as default };

package/dist/packem_shared/reconcile-qE3ERi3D.mjs

@@ -1,85 +0,0 @@
-import { compareMoney } from './addMoney-jSh_7TfF.mjs';
-import { n as notifyObserver } from './observability-CvhJ205g.mjs';
-
-const sameCurrencyAmount = (a, b) => a.currency === b.currency && compareMoney(a, b) === 0;
-const subscriptionDrifted = (existing, current) => existing?.state !== current.state || existing.cancelAtPeriodEnd !== current.cancelAtPeriodEnd || existing.currentPeriodEnd !== current.currentPeriodEnd || existing.priceId !== current.priceId || existing.quantity !== current.quantity;
-const paymentDrifted = (existing, current) => existing?.state !== current.state || !sameCurrencyAmount(existing.capturedAmount, current.capturedAmount) || !sameCurrencyAmount(existing.refundedAmount, current.refundedAmount);
-const REFUND_STATES = /* @__PURE__ */ new Set(["partially_refunded", "refunded"]);
-const mergePaymentTruth = (existing, current) => {
-  if (!existing) {
-    return current;
-  }
-  const sameRefundCurrency = existing.refundedAmount.currency === current.refundedAmount.currency;
-  const refundedAmount = sameRefundCurrency && compareMoney(existing.refundedAmount, current.refundedAmount) > 0 ? existing.refundedAmount : current.refundedAmount;
-  const state = current.state === "captured" && REFUND_STATES.has(existing.state) ? existing.state : current.state;
-  const referenceId = current.referenceId === "" ? existing.referenceId : current.referenceId;
-  return { ...current, referenceId, refundedAmount, state };
-};
-const reconcileSubscription = async (adapter, store, id, observer) => {
-  const current = await adapter.getSubscriptionStatus(id);
-  const existing = await store.getSubscription(adapter.identifier, id);
-  if (!subscriptionDrifted(existing, current)) {
-    return false;
-  }
-  await store.upsertSubscription({ ...current, createdAt: existing?.createdAt ?? current.createdAt });
-  notifyObserver(observer, { id, kind: "subscription", provider: adapter.identifier, type: "reconcile.drift" });
-  return true;
-};
-const reconcilePayment = async (adapter, store, id, observer) => {
-  const providerTruth = await adapter.getPaymentStatus(id);
-  const existing = await store.getPaymentSession(adapter.identifier, id);
-  const current = mergePaymentTruth(existing, providerTruth);
-  if (!paymentDrifted(existing, current)) {
-    return false;
-  }
-  await store.upsertPaymentSession({ ...current, createdAt: existing?.createdAt ?? current.createdAt });
-  notifyObserver(observer, { id, kind: "payment", provider: adapter.identifier, type: "reconcile.drift" });
-  return true;
-};
-const sweep = async (ids, kind, reconcileOne, adapter, observer) => {
-  const settled = await Promise.allSettled(ids.map((id) => reconcileOne(id)));
-  let updated = 0;
-  let failed = 0;
-  for (const [index, result] of settled.entries()) {
-    if (result.status === "fulfilled") {
-      if (result.value) {
-        updated += 1;
-      }
-    } else {
-      failed += 1;
-      notifyObserver(observer, { error: result.reason, id: ids[index] ?? "", kind, provider: adapter.identifier, type: "reconcile.error" });
-    }
-  }
-  return { failed, updated };
-};
-const reconcile = async (input) => {
-  const { adapter, observability, store } = input;
-  const subscriptionIds = input.subscriptionIds ?? [];
-  const paymentSessionIds = input.paymentSessionIds ?? [];
-  const subscriptionCounts = await sweep(
-    subscriptionIds,
-    "subscription",
-    (id) => reconcileSubscription(adapter, store, id, observability),
-    adapter,
-    observability
-  );
-  const paymentCounts = await sweep(paymentSessionIds, "payment", (id) => reconcilePayment(adapter, store, id, observability), adapter, observability);
-  notifyObserver(observability, {
-    failedPayments: paymentCounts.failed,
-    failedSubscriptions: subscriptionCounts.failed,
-    provider: adapter.identifier,
-    type: "reconcile.completed",
-    updatedPayments: paymentCounts.updated,
-    updatedSubscriptions: subscriptionCounts.updated
-  });
-  return {
-    checkedPayments: paymentSessionIds.length,
-    checkedSubscriptions: subscriptionIds.length,
-    failedPayments: paymentCounts.failed,
-    failedSubscriptions: subscriptionCounts.failed,
-    updatedPayments: paymentCounts.updated,
-    updatedSubscriptions: subscriptionCounts.updated
-  };
-};
-
-export { reconcile };

package/dist/packem_shared/subscription-event-CwEsWRCK.mjs

@@ -1,17 +0,0 @@
-const stateToEventType = (state) => {
-  if (state === "canceled") {
-    return "subscription.canceled";
-  }
-  if (state === "past_due") {
-    return "subscription.past_due";
-  }
-  if (state === "paused") {
-    return "subscription.paused";
-  }
-  if (state === "active" || state === "trialing") {
-    return "subscription.active";
-  }
-  return "subscription.updated";
-};
-
-export { stateToEventType as s };