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

package/dist/packem_shared/paymentTables-D4TbhaIk.mjs

@@ -0,0 +1,59 @@
+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-CI1ukJF9.mjs → reconcile-qE3ERi3D.mjs}

@@ -1,9 +1,20 @@
-import { compareMoney } from './addMoney-bCcs1nyw.mjs';
+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);
@@ -15,8 +26,9 @@ const reconcileSubscription = async (adapter, store, id, observer) => {
   return true;
 };
 const reconcilePayment = async (adapter, store, id, observer) => {
-  const current = await adapter.getPaymentStatus(id);
+  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;
   }

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

@@ -0,0 +1,17 @@
+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 };

package/dist/providers/autumn-features.d.mts

@@ -0,0 +1,129 @@
+/**
+ * A per-seat / per-workspace sub-customer with its own feature balances.
+ * @experimental
+ */
+interface AutumnEntity {
+  readonly featureId?: string;
+  readonly id: string;
+  readonly name?: string;
+  /** The raw provider record, for fields this facade does not normalize. */
+  readonly raw: Record<string, unknown>;
+}
+/**
+ * `CreateEntityInput` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface CreateEntityInput {
+  /** The feature the entity consumes a seat/allowance of (e.g. `"seats"`). */
+  readonly featureId: string;
+  /** Caller-chosen stable id — Autumn requires an entity id on create. */
+  readonly id: string;
+  readonly name?: string;
+}
+/**
+ * One point in a usage-events aggregation.
+ * @experimental
+ */
+interface UsageEventPoint {
+  readonly count: number;
+  readonly period?: string;
+  readonly raw: Record<string, unknown>;
+}
+/**
+ * `EventsListInput` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface EventsListInput {
+  /** Feature(s) to report on. */
+  readonly featureId: ReadonlyArray<string> | string;
+}
+/**
+ * `EventsAggregateInput` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface EventsAggregateInput extends EventsListInput {
+  /** Time window to aggregate over (aggregate only — `list` ignores it, so it isn't accepted there). */
+  readonly range?: "7d" | "24h" | "30d" | "90d" | "last_cycle";
+}
+/**
+ * A prepaid feature quantity purchased at checkout (e.g. buy 5 seats up front).
+ * @experimental
+ */
+interface PrepaidOption {
+  readonly featureId: string;
+  readonly quantity: number;
+}
+/**
+ * Autumn-native checkout — richer than the generic `createCheckout` (trials, prepaid, entities, rewards).
+ * @experimental
+ */
+interface AutumnCheckoutInput {
+  /** Scope the checkout to a specific entity (seat/workspace) rather than the top-level customer. */
+  readonly entityId?: string;
+  /**
+   * Autumn applies a plan's configured free trial automatically. Pass `false` to opt out of that
+   * trial for this checkout; leave unset (or `true`) to keep the plan default.
+   */
+  readonly freeTrial?: boolean;
+  /** Prepaid feature quantities to purchase up front. */
+  readonly options?: ReadonlyArray<PrepaidOption>;
+  /** The plan to attach (Autumn's plan id — the successor to the classic "product" id). */
+  readonly planId: string;
+  /** An Autumn reward id to apply as a discount. */
+  readonly reward?: string;
+  readonly successUrl?: string;
+}
+/**
+ * The subset of the Autumn SDK surface the native facade calls. A real `Autumn` instance satisfies it.
+ * @experimental
+ */
+interface AutumnFeaturesClientLike {
+  readonly billing: unknown;
+  readonly entities: unknown;
+  readonly events: unknown;
+  readonly plans: unknown;
+  readonly referrals: unknown;
+}
+/**
+ * `AutumnFeaturesOptions` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface AutumnFeaturesOptions {
+  readonly client: AutumnFeaturesClientLike;
+}
+/**
+ * The Autumn-native feature facade returned by {@link createAutumnFeatures}.
+ * @experimental
+ */
+interface AutumnFeatures {
+  readonly checkout: (referenceId: string, input: AutumnCheckoutInput) => Promise<{
+    raw: Record<string, unknown>;
+    url: string;
+  }>;
+  readonly entities: {
+    readonly create: (referenceId: string, input: CreateEntityInput) => Promise<AutumnEntity>;
+    readonly delete: (referenceId: string, entityId: string) => Promise<void>;
+    readonly get: (referenceId: string, entityId: string) => Promise<AutumnEntity>;
+  };
+  readonly events: {
+    readonly aggregate: (referenceId: string, input: EventsAggregateInput) => Promise<UsageEventPoint[]>;
+    readonly list: (referenceId: string, input: EventsListInput) => Promise<UsageEventPoint[]>;
+  };
+  readonly plans: {
+    readonly list: () => Promise<Record<string, unknown>[]>;
+  };
+  readonly referrals: {
+    readonly createCode: (referenceId: string, programId: string) => Promise<{
+      code: string;
+      raw: Record<string, unknown>;
+    }>;
+    readonly redeemCode: (referenceId: string, code: string) => Promise<Record<string, unknown>>;
+  };
+}
+/**
+ * Build the Autumn-native feature facade over an injected client. Companion to `createAutumnAdapter`;
+ * share the same underlying `autumn-js` `Autumn` client between them.
+ * @experimental
+ */
+declare const createAutumnFeatures: (options: AutumnFeaturesOptions) => AutumnFeatures;
+export { type AutumnCheckoutInput, type AutumnEntity, type AutumnFeatures, type AutumnFeaturesClientLike, type AutumnFeaturesOptions, type CreateEntityInput, type EventsAggregateInput, type EventsListInput, type PrepaidOption, type UsageEventPoint, createAutumnFeatures };

package/dist/providers/autumn-features.d.ts

@@ -0,0 +1,129 @@
+/**
+ * A per-seat / per-workspace sub-customer with its own feature balances.
+ * @experimental
+ */
+interface AutumnEntity {
+  readonly featureId?: string;
+  readonly id: string;
+  readonly name?: string;
+  /** The raw provider record, for fields this facade does not normalize. */
+  readonly raw: Record<string, unknown>;
+}
+/**
+ * `CreateEntityInput` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface CreateEntityInput {
+  /** The feature the entity consumes a seat/allowance of (e.g. `"seats"`). */
+  readonly featureId: string;
+  /** Caller-chosen stable id — Autumn requires an entity id on create. */
+  readonly id: string;
+  readonly name?: string;
+}
+/**
+ * One point in a usage-events aggregation.
+ * @experimental
+ */
+interface UsageEventPoint {
+  readonly count: number;
+  readonly period?: string;
+  readonly raw: Record<string, unknown>;
+}
+/**
+ * `EventsListInput` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface EventsListInput {
+  /** Feature(s) to report on. */
+  readonly featureId: ReadonlyArray<string> | string;
+}
+/**
+ * `EventsAggregateInput` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface EventsAggregateInput extends EventsListInput {
+  /** Time window to aggregate over (aggregate only — `list` ignores it, so it isn't accepted there). */
+  readonly range?: "7d" | "24h" | "30d" | "90d" | "last_cycle";
+}
+/**
+ * A prepaid feature quantity purchased at checkout (e.g. buy 5 seats up front).
+ * @experimental
+ */
+interface PrepaidOption {
+  readonly featureId: string;
+  readonly quantity: number;
+}
+/**
+ * Autumn-native checkout — richer than the generic `createCheckout` (trials, prepaid, entities, rewards).
+ * @experimental
+ */
+interface AutumnCheckoutInput {
+  /** Scope the checkout to a specific entity (seat/workspace) rather than the top-level customer. */
+  readonly entityId?: string;
+  /**
+   * Autumn applies a plan's configured free trial automatically. Pass `false` to opt out of that
+   * trial for this checkout; leave unset (or `true`) to keep the plan default.
+   */
+  readonly freeTrial?: boolean;
+  /** Prepaid feature quantities to purchase up front. */
+  readonly options?: ReadonlyArray<PrepaidOption>;
+  /** The plan to attach (Autumn's plan id — the successor to the classic "product" id). */
+  readonly planId: string;
+  /** An Autumn reward id to apply as a discount. */
+  readonly reward?: string;
+  readonly successUrl?: string;
+}
+/**
+ * The subset of the Autumn SDK surface the native facade calls. A real `Autumn` instance satisfies it.
+ * @experimental
+ */
+interface AutumnFeaturesClientLike {
+  readonly billing: unknown;
+  readonly entities: unknown;
+  readonly events: unknown;
+  readonly plans: unknown;
+  readonly referrals: unknown;
+}
+/**
+ * `AutumnFeaturesOptions` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface AutumnFeaturesOptions {
+  readonly client: AutumnFeaturesClientLike;
+}
+/**
+ * The Autumn-native feature facade returned by {@link createAutumnFeatures}.
+ * @experimental
+ */
+interface AutumnFeatures {
+  readonly checkout: (referenceId: string, input: AutumnCheckoutInput) => Promise<{
+    raw: Record<string, unknown>;
+    url: string;
+  }>;
+  readonly entities: {
+    readonly create: (referenceId: string, input: CreateEntityInput) => Promise<AutumnEntity>;
+    readonly delete: (referenceId: string, entityId: string) => Promise<void>;
+    readonly get: (referenceId: string, entityId: string) => Promise<AutumnEntity>;
+  };
+  readonly events: {
+    readonly aggregate: (referenceId: string, input: EventsAggregateInput) => Promise<UsageEventPoint[]>;
+    readonly list: (referenceId: string, input: EventsListInput) => Promise<UsageEventPoint[]>;
+  };
+  readonly plans: {
+    readonly list: () => Promise<Record<string, unknown>[]>;
+  };
+  readonly referrals: {
+    readonly createCode: (referenceId: string, programId: string) => Promise<{
+      code: string;
+      raw: Record<string, unknown>;
+    }>;
+    readonly redeemCode: (referenceId: string, code: string) => Promise<Record<string, unknown>>;
+  };
+}
+/**
+ * Build the Autumn-native feature facade over an injected client. Companion to `createAutumnAdapter`;
+ * share the same underlying `autumn-js` `Autumn` client between them.
+ * @experimental
+ */
+declare const createAutumnFeatures: (options: AutumnFeaturesOptions) => AutumnFeatures;
+export { type AutumnCheckoutInput, type AutumnEntity, type AutumnFeatures, type AutumnFeaturesClientLike, type AutumnFeaturesOptions, type CreateEntityInput, type EventsAggregateInput, type EventsListInput, type PrepaidOption, type UsageEventPoint, createAutumnFeatures };

package/dist/providers/autumn-features.mjs

@@ -0,0 +1,95 @@
+import { a as asRecord, r as readString, b as readNumber } from '../packem_shared/json-D0Cb5aMv.mjs';
+
+const toFeatureId = (featureId) => typeof featureId === "string" ? featureId : [...featureId];
+const entityFrom = (record) => {
+  return {
+    featureId: readString(record, "featureId") ?? readString(record, "feature_id"),
+    id: readString(record, "id") ?? "",
+    name: readString(record, "name"),
+    raw: record
+  };
+};
+const pointsFrom = (result) => {
+  const list = result.list ?? result.data ?? result.events;
+  const rows = Array.isArray(list) ? list : [];
+  return rows.map((entry) => {
+    const record = asRecord(entry);
+    return { count: readNumber(record, "count") ?? readNumber(record, "value") ?? 0, period: readString(record, "period"), raw: record };
+  });
+};
+const createAutumnFeatures = (options) => {
+  const client = options.client;
+  return {
+    /**
+     * Native Autumn checkout — supports opting out of a plan's free trial, prepaid feature
+     * quantities, entity scoping, and reward codes. Returns the hosted checkout URL (empty when
+     * Autumn applied the change directly without a payment step).
+     */
+    checkout: async (referenceId, input) => {
+      const result = asRecord(
+        await client.billing.attach({
+          customerId: referenceId,
+          // Autumn applies the plan's configured trial by default; `null` opts this checkout out.
+          // eslint-disable-next-line unicorn/no-null -- the SDK's customize.freeTrial requires null (not undefined) to disable
+          ...input.freeTrial === false ? { customize: { freeTrial: null } } : {},
+          discounts: input.reward ? [{ rewardId: input.reward }] : void 0,
+          entityId: input.entityId,
+          featureQuantities: input.options?.map((option) => {
+            return { featureId: option.featureId, quantity: option.quantity };
+          }),
+          planId: input.planId,
+          successUrl: input.successUrl
+        })
+      );
+      const url = readString(result, "paymentUrl") ?? readString(result, "checkoutUrl") ?? readString(result, "url") ?? "";
+      return { raw: result, url };
+    },
+    entities: {
+      /** Create a per-seat / per-workspace sub-customer under a reference. */
+      create: async (referenceId, input) => {
+        const created = await client.entities.create({ customerId: referenceId, entityId: input.id, featureId: input.featureId, name: input.name });
+        return entityFrom(asRecord(created));
+      },
+      /** Remove an entity — frees its seat/allowance. */
+      delete: async (referenceId, entityId) => {
+        await client.entities.delete({ customerId: referenceId, entityId });
+      },
+      /** Fetch one entity and its balances. */
+      get: async (referenceId, entityId) => {
+        const entity = await client.entities.get({ customerId: referenceId, entityId });
+        return entityFrom(asRecord(entity));
+      }
+    },
+    events: {
+      /** Bucketed usage aggregation for a reference's feature(s) over a range. */
+      aggregate: async (referenceId, input) => {
+        const result = await client.events.aggregate({ customerId: referenceId, featureId: toFeatureId(input.featureId), range: input.range });
+        return pointsFrom(asRecord(result));
+      },
+      /** Raw usage events for a reference's feature(s). */
+      list: async (referenceId, input) => {
+        const result = await client.events.list({ customerId: referenceId, featureId: toFeatureId(input.featureId) });
+        return pointsFrom(asRecord(result));
+      }
+    },
+    plans: {
+      /** The configured plan catalog. */
+      list: async () => {
+        const result = asRecord(await client.plans.list());
+        const list = result.list ?? result.data ?? result.plans;
+        return Array.isArray(list) ? list.map((entry) => asRecord(entry)) : [];
+      }
+    },
+    referrals: {
+      /** Mint (or fetch) a referral code for a reference in a referral program. */
+      createCode: async (referenceId, programId) => {
+        const result = asRecord(await client.referrals.createCode({ customerId: referenceId, programId }));
+        return { code: readString(result, "code") ?? "", raw: result };
+      },
+      /** Redeem a referral code on behalf of a reference. */
+      redeemCode: async (referenceId, code) => asRecord(await client.referrals.redeemCode({ code, customerId: referenceId }))
+    }
+  };
+};
+
+export { createAutumnFeatures };

package/dist/providers/autumn.d.mts

@@ -0,0 +1,28 @@
+import { P as PaymentAdapter } from "../packem_shared/adapter.d-CMjjkTGB.mjs";
+/**
+ * The `autumn-js` SDK surface the adapter uses, as a structural type — a real `Autumn` instance
+ * satisfies it without a cast. Resources/methods are `unknown` (the adapter re-types the client as
+ * the real `Autumn` internally); this keeps the SDK's full type out of the published declarations.
+ * @experimental
+ */
+interface AutumnClientLike {
+  readonly billing: unknown;
+  readonly check: unknown;
+  readonly customers: unknown;
+  readonly track: unknown;
+}
+/**
+ * `AutumnAdapterOptions` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface AutumnAdapterOptions {
+  readonly client: AutumnClientLike;
+  readonly webhookSecret: string;
+  readonly webhookToleranceSeconds?: number;
+}
+/**
+ * `createAutumnAdapter` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+declare const createAutumnAdapter: (options: AutumnAdapterOptions) => PaymentAdapter;
+export { type AutumnAdapterOptions, type AutumnClientLike, createAutumnAdapter };

package/dist/providers/autumn.d.ts

@@ -0,0 +1,28 @@
+import { P as PaymentAdapter } from "../packem_shared/adapter.d-CMjjkTGB.js";
+/**
+ * The `autumn-js` SDK surface the adapter uses, as a structural type — a real `Autumn` instance
+ * satisfies it without a cast. Resources/methods are `unknown` (the adapter re-types the client as
+ * the real `Autumn` internally); this keeps the SDK's full type out of the published declarations.
+ * @experimental
+ */
+interface AutumnClientLike {
+  readonly billing: unknown;
+  readonly check: unknown;
+  readonly customers: unknown;
+  readonly track: unknown;
+}
+/**
+ * `AutumnAdapterOptions` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface AutumnAdapterOptions {
+  readonly client: AutumnClientLike;
+  readonly webhookSecret: string;
+  readonly webhookToleranceSeconds?: number;
+}
+/**
+ * `createAutumnAdapter` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+declare const createAutumnAdapter: (options: AutumnAdapterOptions) => PaymentAdapter;
+export { type AutumnAdapterOptions, type AutumnClientLike, createAutumnAdapter };