@lunora/payment 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/isZeroDecimalCurrency-bCcs1nyw.mjs

@@ -0,0 +1,60 @@
+import { toSnapshot } from 'dinero.js';
+import { add, allocate, compare, subtract, dinero } from 'dinero.js/bigint';
+import { LunoraPaymentError } from './LunoraPaymentError-B3hEzXSs.mjs';
+
+const ZERO_DECIMAL = /* @__PURE__ */ new Set(["BIF", "CLP", "DJF", "GNF", "JPY", "KMF", "KRW", "MGA", "PYG", "RWF", "UGX", "VND", "VUV", "XAF", "XOF", "XPF"]);
+const THREE_DECIMAL = /* @__PURE__ */ new Set(["BHD", "IQD", "JOD", "KWD", "LYD", "OMR", "TND"]);
+const exponentFor = (code) => {
+  if (ZERO_DECIMAL.has(code)) {
+    return 0n;
+  }
+  return THREE_DECIMAL.has(code) ? 3n : 2n;
+};
+const currencyFor = (code) => {
+  return { base: 10n, code: code.toUpperCase(), exponent: exponentFor(code.toUpperCase()) };
+};
+const toDinero = (value) => dinero({ amount: value.minorUnits, currency: currencyFor(value.currency) });
+const fromDinero = (value) => {
+  const snapshot = toSnapshot(value);
+  return { currency: snapshot.currency.code, minorUnits: snapshot.amount };
+};
+const assertSameCurrency = (a, b) => {
+  if (a.currency !== b.currency) {
+    throw new LunoraPaymentError("CURRENCY_MISMATCH", `cannot combine ${a.currency} with ${b.currency}`);
+  }
+};
+const isZeroDecimalCurrency = (currency) => exponentFor(currency.toUpperCase()) === 0n;
+const money = (minorUnits, currency) => {
+  const units = typeof minorUnits === "bigint" ? minorUnits : BigInt(Math.trunc(minorUnits));
+  return { currency: currency.toUpperCase(), minorUnits: units };
+};
+const zeroMoney = (currency) => money(0n, currency);
+const formatMoney = (value, locale = "en-US") => {
+  const exponent = Number(exponentFor(value.currency.toUpperCase()));
+  const amount = Number(value.minorUnits) / 10 ** exponent;
+  try {
+    return new Intl.NumberFormat(locale, { currency: value.currency, style: "currency" }).format(amount);
+  } catch {
+    return `${amount.toFixed(exponent)} ${value.currency}`;
+  }
+};
+const addMoney = (a, b) => {
+  assertSameCurrency(a, b);
+  return fromDinero(add(toDinero(a), toDinero(b)));
+};
+const subtractMoney = (a, b) => {
+  assertSameCurrency(a, b);
+  return fromDinero(subtract(toDinero(a), toDinero(b)));
+};
+const compareMoney = (a, b) => {
+  assertSameCurrency(a, b);
+  return compare(toDinero(a), toDinero(b));
+};
+const allocateMoney = (amount, ratios) => allocate(toDinero(amount), [...ratios]).map((part) => fromDinero(part));
+const isZeroMoney = (a) => a.minorUnits === 0n;
+const toMoneyJSON = (m) => {
+  return { currency: m.currency, minorUnits: m.minorUnits.toString() };
+};
+const fromMoneyJSON = (json) => money(BigInt(json.minorUnits), json.currency);
+
+export { addMoney, allocateMoney, compareMoney, formatMoney, fromMoneyJSON, isZeroDecimalCurrency, isZeroMoney, money, subtractMoney, toMoneyJSON, zeroMoney };

package/dist/packem_shared/json-Db337f36.mjs

@@ -0,0 +1,6 @@
+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;
+
+export { asRecord as a, readBoolean as b, readNumber as c, readString as r };

package/dist/packem_shared/lunoraDatabaseToPaymentDatabase-D_ViFvZV.mjs

@@ -0,0 +1,29 @@
+import { createPayment } from './createPayment-DG97pe-f.mjs';
+import { createDatabasePaymentStore } from './createDatabasePaymentStore-C0hXSKmj.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/observability-CvhJ205g.mjs

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

package/dist/packem_shared/paymentTables-DccHwWr_.mjs

@@ -0,0 +1,127 @@
+import { defineTable } from '@lunora/server';
+import { v } from '@lunora/values';
+
+const products = defineTable({
+  description: v.optional(v.string()),
+  name: v.string(),
+  provider: v.string(),
+  providerProductId: v.string()
+}).index("by_provider_product", ["provider", "providerProductId"], { unique: true });
+const prices = defineTable({
+  active: v.boolean(),
+  amountMinor: v.bigint(),
+  currency: v.string(),
+  interval: v.optional(v.string()),
+  provider: v.string(),
+  providerPriceId: v.string(),
+  providerProductId: v.string()
+}).index("by_provider_price", ["provider", "providerPriceId"], { unique: true });
+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 checkouts = defineTable({
+  createdAt: v.number(),
+  mode: v.string(),
+  priceId: v.string(),
+  provider: v.string(),
+  providerCheckoutId: v.string(),
+  referenceId: v.string(),
+  url: v.string()
+}).index("by_provider_checkout", ["provider", "providerCheckoutId"], { unique: true });
+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 payments = defineTable({
+  amountMinor: v.bigint(),
+  createdAt: v.number(),
+  currency: v.string(),
+  provider: v.string(),
+  providerPaymentId: v.string(),
+  referenceId: v.string(),
+  sessionId: v.string(),
+  status: v.string()
+}).index("by_provider_payment", ["provider", "providerPaymentId"], { unique: true });
+const captures = defineTable({
+  amountMinor: v.bigint(),
+  createdAt: v.number(),
+  currency: v.string(),
+  provider: v.string(),
+  providerCaptureId: v.string(),
+  sessionId: v.string()
+}).index("by_session", ["sessionId"]);
+const refunds = defineTable({
+  amountMinor: v.bigint(),
+  createdAt: v.number(),
+  currency: v.string(),
+  provider: v.string(),
+  providerRefundId: v.string(),
+  reason: v.optional(v.string()),
+  sessionId: v.string()
+}).index("by_session", ["sessionId"]);
+const invoices = defineTable({
+  amountMinor: v.bigint(),
+  createdAt: v.number(),
+  currency: v.string(),
+  provider: v.string(),
+  providerInvoiceId: v.string(),
+  referenceId: v.string(),
+  status: v.string(),
+  subscriptionId: v.optional(v.string())
+}).index("by_provider_invoice", ["provider", "providerInvoiceId"], { unique: true });
+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 = {
+  captures,
+  checkouts,
+  customers,
+  events,
+  invoices,
+  paymentSessions,
+  payments,
+  prices,
+  products,
+  refunds,
+  subscriptions,
+  usageEvents
+};
+
+export { paymentTables as default };

package/dist/packem_shared/reconcile-BhJCfqcT.mjs

@@ -0,0 +1,73 @@
+import { compareMoney } from './isZeroDecimalCurrency-bCcs1nyw.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 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 current = await adapter.getPaymentStatus(id);
+  const existing = await store.getPaymentSession(adapter.identifier, id);
+  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/usagePeriodStart-CzZGXPoZ.mjs

@@ -0,0 +1,51 @@
+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/package.json

@@ -1,32 +1,65 @@
 {
   "name": "@lunora/payment",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.1",
   "description": "Provider-agnostic payments for Lunora: Stripe-first adapter, webhook sync, and subscription/payment state machine",
-  "license": "FSL-1.1-Apache-2.0",
-  "homepage": "https://lunora.sh",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/anolilab/lunora.git",
-    "directory": "packages/payment"
-  },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
-  },
   "keywords": [
-    "lunora",
+    "billing",
     "cloudflare",
-    "workers",
     "durable-objects",
+    "lunora",
     "payment",
-    "billing",
     "stripe",
     "subscriptions",
-    "webhooks"
+    "webhooks",
+    "workers"
   ],
+  "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
+  "license": "FSL-1.1-Apache-2.0",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anolilab/lunora.git",
+    "directory": "packages/payment"
+  },
+  "files": [
+    "dist",
+    "__assets__",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "dependencies": {
+    "@lunora/server": "1.0.0-alpha.1",
+    "@lunora/values": "1.0.0-alpha.1",
+    "dinero.js": "2.0.2"
+  },
+  "peerDependencies": {
+    "stripe": "^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "stripe": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }