payweave 0.0.0

package/dist/db/mongodb/index.js

@@ -0,0 +1,934 @@
+import { PW_TABLES, PW_ACTIVE_SUBSCRIPTION_STATUSES, DEFAULT_STALE_CLAIM_AFTER_MS } from '../../chunk-NV3MZF7L.js';
+import { currentPeriod, DAY_MS, WEEK_MS } from '../../chunk-4R5OGOCC.js';
+import { PayweaveConfigError, PayweaveNotFoundError, PayweaveError, PayweaveValidationError } from '../../chunk-HTRGMZFH.js';
+import { randomInt } from 'crypto';
+
+// src/db/mongodb/errors.ts
+function installHintError(cause) {
+  return new PayweaveConfigError(
+    'payweave/db/mongodb: connecting requires the "mongodb" package, which is not installed (it is an optional peerDependency of "payweave"). Run `npm install mongodb` (or your package manager\'s equivalent) and try again.',
+    { cause }
+  );
+}
+var DUPLICATE_KEY_CODE = 11e3;
+function isDuplicateKeyError(error) {
+  const code = error?.code;
+  return code === DUPLICATE_KEY_CODE;
+}
+function wrapDriverError(error, message) {
+  if (error instanceof PayweaveError) return error;
+  if (isDuplicateKeyError(error)) {
+    return new PayweaveValidationError(message, { cause: error });
+  }
+  return new PayweaveError(message, { cause: error, isRetryable: false });
+}
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = ENCODING.length;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function encodeTime(timeMs, len) {
+  if (!Number.isSafeInteger(timeMs) || timeMs < 0) {
+    throw new RangeError(`ulid: time must be a non-negative safe integer \u2014 got ${timeMs}`);
+  }
+  let remaining = timeMs;
+  let out = "";
+  for (let i = 0; i < len; i++) {
+    const mod = remaining % ENCODING_LEN;
+    out = ENCODING.charAt(mod) + out;
+    remaining = Math.floor(remaining / ENCODING_LEN);
+  }
+  return out;
+}
+function encodeRandom(len) {
+  let out = "";
+  for (let i = 0; i < len; i++) {
+    out += ENCODING.charAt(randomInt(0, ENCODING_LEN));
+  }
+  return out;
+}
+function ulid(timeMs = Date.now()) {
+  return encodeTime(timeMs, TIME_LEN) + encodeRandom(RANDOM_LEN);
+}
+function generatePwId(timeMs = Date.now()) {
+  return `pwv_${ulid(timeMs)}`;
+}
+
+// src/db/mongodb/migrations.ts
+var MIGRATION_NAME = "0001_init";
+var REQUIRED_INDEXES = [
+  {
+    collection: PW_TABLES.customers,
+    name: "pw_customers_externalId_unique",
+    key: { externalId: 1 },
+    options: { unique: true }
+  },
+  {
+    collection: PW_TABLES.plans,
+    name: "pw_plans_planId_version_unique",
+    key: { planId: 1, version: 1 },
+    options: { unique: true }
+  },
+  {
+    collection: PW_TABLES.subscriptions,
+    name: "pw_subscriptions_active_unique",
+    key: { customerId: 1, group: 1 },
+    options: {
+      unique: true,
+      // The §2 partial-unique active-subscription rule: at most one row per
+      // (customerId, group) whose status is in the active set — everything
+      // else (canceled/incomplete, and any OTHER status a community fork
+      // might add) falls outside the filter and never collides.
+      partialFilterExpression: { status: { $in: [...PW_ACTIVE_SUBSCRIPTION_STATUSES] } }
+    }
+  },
+  {
+    collection: PW_TABLES.featureBalances,
+    name: "pw_feature_balances_unique",
+    key: { customerId: 1, featureId: 1, group: 1 },
+    options: { unique: true }
+  }
+];
+function isNamespaceNotFound(error) {
+  const code = error?.code;
+  return code === 26;
+}
+async function existingIndexNames(db, collectionName) {
+  try {
+    const infos = await db.collection(collectionName).indexes();
+    return new Set(infos.map((i) => i.name).filter((n) => typeof n === "string"));
+  } catch (error) {
+    if (isNamespaceNotFound(error)) return /* @__PURE__ */ new Set();
+    throw error;
+  }
+}
+async function missingIndexes(db) {
+  const missing = [];
+  const byCollection = /* @__PURE__ */ new Map();
+  for (const required of REQUIRED_INDEXES) {
+    let names = byCollection.get(required.collection);
+    if (!names) {
+      names = await existingIndexNames(db, required.collection);
+      byCollection.set(required.collection, names);
+    }
+    if (!names.has(required.name)) missing.push(required);
+  }
+  return missing;
+}
+async function mongoMigrationStatus(db) {
+  const missing = await missingIndexes(db);
+  return missing.length === 0 ? { pending: [], applied: [MIGRATION_NAME] } : { pending: [MIGRATION_NAME], applied: [] };
+}
+async function mongoMigrationApply(db) {
+  const missing = await missingIndexes(db);
+  if (missing.length === 0) return { applied: [] };
+  for (const required of missing) {
+    await db.collection(required.collection).createIndex(required.key, {
+      name: required.name,
+      ...required.options
+    });
+  }
+  return { applied: [MIGRATION_NAME] };
+}
+
+// src/db/mongodb/period-pipeline.ts
+function buildPeriodExpr(nowMs, anchorExpr, resetExpr) {
+  const nowLiteral = new Date(nowMs);
+  return {
+    $let: {
+      vars: { anchor: anchorExpr, reset: resetExpr },
+      in: {
+        $switch: {
+          branches: [
+            {
+              case: { $in: ["$$reset", ["day", "week"]] },
+              then: {
+                $let: {
+                  vars: { periodMs: { $cond: [{ $eq: ["$$reset", "day"] }, DAY_MS, WEEK_MS] } },
+                  in: {
+                    $let: {
+                      vars: {
+                        idx: {
+                          $max: [
+                            0,
+                            {
+                              $floor: {
+                                $divide: [{ $subtract: [nowLiteral, "$$anchor"] }, "$$periodMs"]
+                              }
+                            }
+                          ]
+                        }
+                      },
+                      in: {
+                        index: "$$idx",
+                        start: { $add: ["$$anchor", { $multiply: ["$$idx", "$$periodMs"] }] },
+                        end: {
+                          $add: ["$$anchor", { $multiply: [{ $add: ["$$idx", 1] }, "$$periodMs"] }]
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          ],
+          default: {
+            $let: {
+              vars: {
+                monthsPerPeriod: { $cond: [{ $eq: ["$$reset", "year"] }, 12, 1] },
+                anchorParts: { $dateToParts: { date: "$$anchor", timezone: "UTC" } },
+                nowParts: { $dateToParts: { date: nowLiteral, timezone: "UTC" } }
+              },
+              in: {
+                $let: {
+                  vars: {
+                    monthDiff: {
+                      $add: [
+                        { $multiply: [{ $subtract: ["$$nowParts.year", "$$anchorParts.year"] }, 12] },
+                        { $subtract: ["$$nowParts.month", "$$anchorParts.month"] }
+                      ]
+                    }
+                  },
+                  in: {
+                    $let: {
+                      vars: {
+                        idx0: {
+                          $max: [
+                            0,
+                            {
+                              $subtract: [
+                                { $floor: { $divide: ["$$monthDiff", "$$monthsPerPeriod"] } },
+                                1
+                              ]
+                            }
+                          ]
+                        }
+                      },
+                      in: {
+                        $let: {
+                          vars: {
+                            end0: {
+                              $dateAdd: {
+                                startDate: "$$anchor",
+                                unit: "month",
+                                amount: { $multiply: [{ $add: ["$$idx0", 1] }, "$$monthsPerPeriod"] }
+                              }
+                            },
+                            end1: {
+                              $dateAdd: {
+                                startDate: "$$anchor",
+                                unit: "month",
+                                amount: { $multiply: [{ $add: ["$$idx0", 2] }, "$$monthsPerPeriod"] }
+                              }
+                            },
+                            end2: {
+                              $dateAdd: {
+                                startDate: "$$anchor",
+                                unit: "month",
+                                amount: { $multiply: [{ $add: ["$$idx0", 3] }, "$$monthsPerPeriod"] }
+                              }
+                            },
+                            end3: {
+                              $dateAdd: {
+                                startDate: "$$anchor",
+                                unit: "month",
+                                amount: { $multiply: [{ $add: ["$$idx0", 4] }, "$$monthsPerPeriod"] }
+                              }
+                            }
+                          },
+                          in: {
+                            $let: {
+                              vars: {
+                                chosenIdx: {
+                                  $switch: {
+                                    branches: [
+                                      { case: { $lt: [nowLiteral, "$$end0"] }, then: "$$idx0" },
+                                      {
+                                        case: { $lt: [nowLiteral, "$$end1"] },
+                                        then: { $add: ["$$idx0", 1] }
+                                      },
+                                      {
+                                        case: { $lt: [nowLiteral, "$$end2"] },
+                                        then: { $add: ["$$idx0", 2] }
+                                      }
+                                    ],
+                                    default: { $add: ["$$idx0", 3] }
+                                  }
+                                },
+                                chosenEnd: {
+                                  $switch: {
+                                    branches: [
+                                      { case: { $lt: [nowLiteral, "$$end0"] }, then: "$$end0" },
+                                      { case: { $lt: [nowLiteral, "$$end1"] }, then: "$$end1" },
+                                      { case: { $lt: [nowLiteral, "$$end2"] }, then: "$$end2" }
+                                    ],
+                                    default: "$$end3"
+                                  }
+                                }
+                              },
+                              in: {
+                                index: "$$chosenIdx",
+                                start: {
+                                  $dateAdd: {
+                                    startDate: "$$anchor",
+                                    unit: "month",
+                                    amount: { $multiply: ["$$chosenIdx", "$$monthsPerPeriod"] }
+                                  }
+                                },
+                                end: "$$chosenEnd"
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/db/mongodb/rows.ts
+function docToCustomer(doc) {
+  return {
+    id: doc._id,
+    externalId: doc.externalId,
+    providerIds: doc.providerIds ?? {},
+    email: doc.email ?? null,
+    createdAt: doc.createdAt,
+    updatedAt: doc.updatedAt
+  };
+}
+function docToPlanVersion(doc) {
+  return {
+    id: doc._id,
+    planId: doc.planId,
+    version: doc.version,
+    group: doc.group,
+    isDefault: doc.isDefault,
+    name: doc.name,
+    priceMinor: doc.priceMinor,
+    priceCurrency: doc.priceCurrency,
+    priceInterval: doc.priceInterval,
+    features: doc.features,
+    providerRefs: doc.providerRefs,
+    pushedAt: doc.pushedAt
+  };
+}
+function docToSubscription(doc) {
+  return {
+    id: doc._id,
+    customerId: doc.customerId,
+    planId: doc.planId,
+    planVersion: doc.planVersion,
+    group: doc.group,
+    status: doc.status,
+    provider: doc.provider,
+    providerSubscriptionRef: doc.providerSubscriptionRef,
+    currentPeriodStart: doc.currentPeriodStart,
+    currentPeriodEnd: doc.currentPeriodEnd,
+    cancelAtPeriodEnd: doc.cancelAtPeriodEnd,
+    createdAt: doc.createdAt,
+    updatedAt: doc.updatedAt
+  };
+}
+function docToFeatureBalance(doc) {
+  return {
+    id: doc._id,
+    customerId: doc.customerId,
+    featureId: doc.featureId,
+    group: doc.group,
+    used: doc.used,
+    limit: doc.limit,
+    resetInterval: doc.resetInterval,
+    anchor: doc.anchor,
+    periodStart: doc.periodStart,
+    periodEnd: doc.periodEnd,
+    planId: doc.planId,
+    planVersion: doc.planVersion,
+    updatedAt: doc.updatedAt
+  };
+}
+
+// src/db/mongodb/topology.ts
+var UNSUPPORTED_MESSAGE_PATTERN = /transaction numbers are only allowed on a replica set member or mongos|this mongodb deployment does not support transactions|transactions are not supported|standalone/i;
+function isTransactionsUnsupportedError(error) {
+  if (error === null || typeof error !== "object") return false;
+  const record = error;
+  const message = typeof record.message === "string" ? record.message : "";
+  if (message.length === 0) return false;
+  if (record.code === 20 && /transaction/i.test(message)) return true;
+  return /transaction/i.test(message) && UNSUPPORTED_MESSAGE_PATTERN.test(message);
+}
+async function runTransaction(client, fn) {
+  const session = client.startSession();
+  try {
+    let result;
+    try {
+      await session.withTransaction(async () => {
+        result = await fn(session);
+      });
+      return result;
+    } catch (error) {
+      if (isTransactionsUnsupportedError(error)) {
+        return await fn(void 0);
+      }
+      throw error;
+    }
+  } finally {
+    await session.endSession();
+  }
+}
+
+// src/db/mongodb/adapter.ts
+var ACTIVE_STATUSES = [...PW_ACTIVE_SUBSCRIPTION_STATUSES];
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+    );
+    return `{${entries.map(([key, val]) => `${JSON.stringify(key)}:${stableStringify(val)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+var planContent = (p) => ({
+  group: p.group,
+  isDefault: p.isDefault,
+  name: p.name,
+  priceMinor: p.priceMinor,
+  priceCurrency: p.priceCurrency,
+  priceInterval: p.priceInterval,
+  features: p.features,
+  providerRefs: p.providerRefs
+});
+function planContentEquals(active, input) {
+  return stableStringify(planContent(active)) === stableStringify(planContent(input));
+}
+function lit(value) {
+  return { $literal: value };
+}
+var SUBSCRIPTION_PATCH_KEYS = [
+  "planId",
+  "planVersion",
+  "status",
+  "provider",
+  "providerSubscriptionRef",
+  "currentPeriodStart",
+  "currentPeriodEnd",
+  "cancelAtPeriodEnd"
+];
+function buildAdapter(deps) {
+  const sessionOpt = deps.session ? { session: deps.session } : {};
+  const customers = deps.db.collection(PW_TABLES.customers);
+  const plans = deps.db.collection(PW_TABLES.plans);
+  const subscriptions = deps.db.collection(PW_TABLES.subscriptions);
+  const balances = deps.db.collection(PW_TABLES.featureBalances);
+  const webhookEvents = deps.db.collection(PW_TABLES.webhookEvents);
+  return {
+    dialect: "mongodb",
+    customers: {
+      getByExternalId: (externalId) => customersGetByExternalId(customers, externalId, sessionOpt),
+      upsert: (input) => customersUpsert(customers, input, sessionOpt),
+      linkProviderRef: (externalId, provider, ref) => customersLinkProviderRef(customers, externalId, provider, ref, sessionOpt)
+    },
+    plans: {
+      getActiveVersion: (planId) => plansGetActiveVersion(plans, planId, sessionOpt),
+      listActive: () => plansListActive(plans, sessionOpt),
+      pushVersion: (plan) => plansPushVersion(plans, plan, sessionOpt)
+    },
+    subscriptions: {
+      getActive: (customerId, group) => subscriptionsGetActive(subscriptions, customerId, group, sessionOpt),
+      create: (input) => subscriptionsCreate(subscriptions, input, sessionOpt),
+      update: (id, patch) => subscriptionsUpdate(subscriptions, id, patch, sessionOpt)
+    },
+    balances: {
+      get: (customerId, featureId, group) => balancesGet(balances, customerId, featureId, group, sessionOpt),
+      consume: (input) => balancesConsume(balances, input, sessionOpt),
+      resetTo: (customerId, featureId, group, init) => balancesResetTo(balances, customerId, featureId, group, init, sessionOpt)
+    },
+    webhookEvents: {
+      claim: (dedupeKey, meta) => webhookEventsClaim(webhookEvents, dedupeKey, meta, sessionOpt),
+      markApplied: (dedupeKey) => webhookEventsMarkApplied(webhookEvents, dedupeKey, sessionOpt)
+    },
+    migrations: {
+      status: () => mongoMigrationStatus(deps.db),
+      apply: () => mongoMigrationApply(deps.db)
+    },
+    transaction: (fn) => runTransaction(deps.client, (session) => fn(buildAdapter({ ...deps, session })))
+  };
+}
+async function customersGetByExternalId(collection, externalId, sessionOpt) {
+  const doc = await collection.findOne({ externalId }, sessionOpt);
+  return doc ? docToCustomer(doc) : null;
+}
+async function customersUpsert(collection, input, sessionOpt) {
+  const now = /* @__PURE__ */ new Date();
+  const generatedId = generatePwId(now.getTime());
+  const emailExpr = input.email !== void 0 ? lit(input.email) : { $ifNull: ["$email", null] };
+  try {
+    const doc = await collection.findOneAndUpdate(
+      { externalId: input.externalId },
+      [
+        {
+          $set: {
+            _id: { $ifNull: ["$_id", lit(generatedId)] },
+            externalId: lit(input.externalId),
+            providerIds: { $ifNull: ["$providerIds", {}] },
+            email: emailExpr,
+            createdAt: { $ifNull: ["$createdAt", now] },
+            updatedAt: now
+          }
+        }
+      ],
+      { upsert: true, returnDocument: "after", ...sessionOpt }
+    );
+    if (!doc) throw new Error("mongodb adapter: customers.upsert returned no document");
+    return docToCustomer(doc);
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/mongodb: customers.upsert(${JSON.stringify(input.externalId)}) failed.`
+    );
+  }
+}
+async function customersLinkProviderRef(collection, externalId, provider, ref, sessionOpt) {
+  const result = await collection.updateOne(
+    { externalId },
+    { $set: { [`providerIds.${provider}`]: ref, updatedAt: /* @__PURE__ */ new Date() } },
+    sessionOpt
+  );
+  if (result.matchedCount === 0) {
+    throw new PayweaveNotFoundError(
+      `payweave/db/mongodb: customers.linkProviderRef: no customer with externalId ${JSON.stringify(externalId)}.`
+    );
+  }
+}
+async function plansGetActiveVersion(collection, planId, sessionOpt) {
+  const doc = await collection.findOne({ planId }, { sort: { version: -1 }, ...sessionOpt });
+  return doc ? docToPlanVersion(doc) : null;
+}
+async function plansListActive(collection, sessionOpt) {
+  const docs = await collection.aggregate(
+    [
+      { $sort: { planId: 1, version: -1 } },
+      { $group: { _id: "$planId", doc: { $first: "$$ROOT" } } },
+      { $replaceRoot: { newRoot: "$doc" } }
+    ],
+    sessionOpt
+  ).toArray();
+  return docs.map(docToPlanVersion);
+}
+var PUSH_VERSION_MAX_ATTEMPTS = 5;
+async function plansPushVersion(collection, plan, sessionOpt) {
+  for (let attempt = 0; attempt < PUSH_VERSION_MAX_ATTEMPTS; attempt++) {
+    const active = await plansGetActiveVersion(collection, plan.planId, sessionOpt);
+    if (active && planContentEquals(active, plan)) return active;
+    const now = /* @__PURE__ */ new Date();
+    const nextVersion = (active?.version ?? 0) + 1;
+    const doc = {
+      _id: generatePwId(now.getTime()),
+      planId: plan.planId,
+      version: nextVersion,
+      group: plan.group,
+      isDefault: plan.isDefault,
+      name: plan.name,
+      priceMinor: plan.priceMinor,
+      priceCurrency: plan.priceCurrency,
+      priceInterval: plan.priceInterval,
+      features: plan.features,
+      providerRefs: plan.providerRefs,
+      pushedAt: now
+    };
+    try {
+      await collection.insertOne(doc, sessionOpt);
+      return docToPlanVersion(doc);
+    } catch (error) {
+      if (isDuplicateKeyError(error) && attempt < PUSH_VERSION_MAX_ATTEMPTS - 1) continue;
+      throw wrapDriverError(
+        error,
+        `payweave/db/mongodb: plans.pushVersion(${JSON.stringify(plan.planId)}) failed.`
+      );
+    }
+  }
+  throw new Error("payweave/db/mongodb: plans.pushVersion exhausted retries under contention");
+}
+async function subscriptionsGetActive(collection, customerId, group, sessionOpt) {
+  const doc = await collection.findOne(
+    { customerId, group, status: { $in: ACTIVE_STATUSES } },
+    sessionOpt
+  );
+  return doc ? docToSubscription(doc) : null;
+}
+async function subscriptionsCreate(collection, input, sessionOpt) {
+  const now = /* @__PURE__ */ new Date();
+  const doc = {
+    _id: generatePwId(now.getTime()),
+    customerId: input.customerId,
+    planId: input.planId,
+    planVersion: input.planVersion,
+    group: input.group,
+    status: input.status,
+    provider: input.provider,
+    providerSubscriptionRef: input.providerSubscriptionRef,
+    currentPeriodStart: input.currentPeriodStart,
+    currentPeriodEnd: input.currentPeriodEnd,
+    cancelAtPeriodEnd: input.cancelAtPeriodEnd,
+    createdAt: now,
+    updatedAt: now
+  };
+  try {
+    await collection.insertOne(doc, sessionOpt);
+    return docToSubscription(doc);
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/mongodb: subscriptions.create for customer ${JSON.stringify(input.customerId)} group ${JSON.stringify(input.group)} violated a uniqueness rule (an active-set subscription already exists for this customer/group, or another constraint failed).`
+    );
+  }
+}
+async function subscriptionsUpdate(collection, id, patch, sessionOpt) {
+  const set = { updatedAt: /* @__PURE__ */ new Date() };
+  const patchRecord = patch;
+  for (const key of SUBSCRIPTION_PATCH_KEYS) {
+    if (!(key in patch) || patchRecord[key] === void 0) continue;
+    set[key] = patchRecord[key];
+  }
+  try {
+    const doc = await collection.findOneAndUpdate(
+      { _id: id },
+      { $set: set },
+      { returnDocument: "after", ...sessionOpt }
+    );
+    if (!doc) {
+      throw new PayweaveNotFoundError(
+        `payweave/db/mongodb: subscriptions.update: no subscription with id ${JSON.stringify(id)}.`
+      );
+    }
+    return docToSubscription(doc);
+  } catch (error) {
+    if (error instanceof PayweaveNotFoundError) throw error;
+    throw wrapDriverError(error, `payweave/db/mongodb: subscriptions.update(${JSON.stringify(id)}) failed.`);
+  }
+}
+async function balancesGet(collection, customerId, featureId, group, sessionOpt) {
+  const doc = await collection.findOne({ customerId, featureId, group }, sessionOpt);
+  return doc ? docToFeatureBalance(doc) : null;
+}
+function buildConsumePipeline(input, generatedId) {
+  const nowMs = input.now.getTime();
+  const nowLiteral = input.now;
+  const conditional = input.conditional === true;
+  const amount = input.amount;
+  return [
+    // A: fill creation defaults. Deliberately does NOT rely on MongoDB
+    // auto-seeding the query filter's equality fields into a fresh upserted
+    // document (that behavior is a real-server implementation detail this
+    // sandbox cannot verify one way or the other) — EVERY field the document
+    // needs, including customerId/featureId/group, is explicitly `$ifNull`'d
+    // from this call's own inputs (the "$ifNull defaults" pattern),
+    // so the pipeline is correct regardless of that assumption.
+    {
+      $set: {
+        _id: { $ifNull: ["$_id", lit(generatedId)] },
+        customerId: { $ifNull: ["$customerId", lit(input.customerId)] },
+        featureId: { $ifNull: ["$featureId", lit(input.featureId)] },
+        group: { $ifNull: ["$group", lit(input.group)] },
+        anchor: { $ifNull: ["$anchor", input.init.anchor] },
+        resetInterval: { $ifNull: ["$resetInterval", lit(input.init.resetInterval)] },
+        limit: { $ifNull: ["$limit", input.init.limit] },
+        planId: { $ifNull: ["$planId", lit(input.init.planId)] },
+        planVersion: { $ifNull: ["$planVersion", input.init.planVersion] },
+        used: { $ifNull: ["$used", 0] }
+      }
+    },
+    // B: the anchor-relative current period (./period-pipeline.ts).
+    {
+      $set: {
+        __period: buildPeriodExpr(nowMs, "$anchor", "$resetInterval")
+      }
+    },
+    // C: reset-due / conditional-gate arithmetic, entirely server-side.
+    {
+      $set: {
+        __hasPeriodEnd: { $ne: [{ $ifNull: ["$periodEnd", null] }, null] }
+      }
+    },
+    {
+      $set: {
+        __resetDue: {
+          $cond: ["$__hasPeriodEnd", { $gte: [nowLiteral, "$periodEnd"] }, true]
+        }
+      }
+    },
+    {
+      $set: {
+        __baseUsed: { $cond: ["$__resetDue", 0, "$used"] }
+      }
+    },
+    // Each of the following stays in its OWN `$set` stage rather than sharing
+    // one with the field it depends on — deliberately conservative given this
+    // sandbox cannot execute a real pipeline to confirm same-stage field
+    // visibility ordering.
+    {
+      $set: {
+        __remaining: { $subtract: ["$limit", "$__baseUsed"] }
+      }
+    },
+    {
+      $set: {
+        __applied: conditional ? { $gte: ["$__remaining", amount] } : true
+      }
+    },
+    {
+      $set: {
+        __finalUsed: {
+          $cond: ["$__applied", { $add: ["$__baseUsed", amount] }, "$__baseUsed"]
+        },
+        __shouldWrite: { $or: ["$__applied", "$__resetDue"] }
+      }
+    },
+    // D: write the real fields — untouched (including `updatedAt`) when
+    // denied AND no reset was due (leave the row untouched in that case).
+    {
+      $set: {
+        used: { $cond: ["$__shouldWrite", "$__finalUsed", "$used"] },
+        periodStart: { $cond: ["$__shouldWrite", "$__period.start", "$periodStart"] },
+        periodEnd: { $cond: ["$__shouldWrite", "$__period.end", "$periodEnd"] },
+        updatedAt: { $cond: ["$__shouldWrite", nowLiteral, { $ifNull: ["$updatedAt", nowLiteral] }] },
+        _pwLastApplied: "$__applied"
+      }
+    },
+    {
+      $unset: [
+        "__period",
+        "__hasPeriodEnd",
+        "__resetDue",
+        "__baseUsed",
+        "__remaining",
+        "__applied",
+        "__finalUsed",
+        "__shouldWrite"
+      ]
+    }
+  ];
+}
+async function balancesConsume(collection, input, sessionOpt) {
+  const generatedId = generatePwId(input.now.getTime());
+  const pipeline = buildConsumePipeline(input, generatedId);
+  const doc = await collection.findOneAndUpdate(
+    { customerId: input.customerId, featureId: input.featureId, group: input.group },
+    pipeline,
+    { upsert: true, returnDocument: "after", ...sessionOpt }
+  );
+  if (!doc) throw new Error("mongodb adapter: balances.consume returned no document");
+  const applied = doc._pwLastApplied ?? true;
+  return { ...docToFeatureBalance(doc), applied };
+}
+async function balancesResetTo(collection, customerId, featureId, group, init, sessionOpt) {
+  const now = /* @__PURE__ */ new Date();
+  const period = currentPeriod(init.anchor.getTime(), init.resetInterval, now.getTime());
+  const generatedId = generatePwId(now.getTime());
+  await collection.findOneAndUpdate(
+    { customerId, featureId, group },
+    [
+      {
+        $set: {
+          _id: { $ifNull: ["$_id", lit(generatedId)] },
+          // Same defensive explicitness as `buildConsumePipeline` — never
+          // rely on MongoDB auto-seeding the filter's equality fields, and
+          // never let a caller-supplied string be misread as a field path.
+          customerId: lit(customerId),
+          featureId: lit(featureId),
+          group: lit(group),
+          used: 0,
+          limit: init.limit,
+          resetInterval: lit(init.resetInterval),
+          anchor: init.anchor,
+          periodStart: new Date(period.start),
+          periodEnd: new Date(period.end),
+          planId: lit(init.planId),
+          planVersion: init.planVersion,
+          updatedAt: now
+        }
+      }
+    ],
+    { upsert: true, ...sessionOpt }
+  );
+}
+function buildClaimPipeline(dedupeKey, meta) {
+  const staleClaimAfterMs = meta.staleClaimAfterMs ?? DEFAULT_STALE_CLAIM_AFTER_MS;
+  const staleThreshold = new Date(meta.now.getTime() - staleClaimAfterMs);
+  return [
+    {
+      $set: {
+        // Same defensive explicitness as `buildConsumePipeline` — never rely
+        // on MongoDB auto-seeding the `_id` filter's equality match on
+        // upsert, and never let a caller-supplied string be misread as a
+        // field path.
+        _id: { $ifNull: ["$_id", lit(dedupeKey)] },
+        provider: { $ifNull: ["$provider", lit(meta.provider)] },
+        type: { $ifNull: ["$type", lit(meta.type)] },
+        receivedAt: { $ifNull: ["$receivedAt", meta.now] },
+        appliedAt: { $ifNull: ["$appliedAt", null] },
+        claimedAt: { $ifNull: ["$claimedAt", null] }
+      }
+    },
+    {
+      $set: {
+        _pwWon: {
+          $and: [
+            { $eq: ["$appliedAt", null] },
+            { $or: [{ $eq: ["$claimedAt", null] }, { $lte: ["$claimedAt", staleThreshold] }] }
+          ]
+        }
+      }
+    },
+    {
+      $set: {
+        claimedAt: { $cond: ["$_pwWon", meta.now, "$claimedAt"] }
+      }
+    }
+  ];
+}
+async function webhookEventsClaim(collection, dedupeKey, meta, sessionOpt) {
+  const pipeline = buildClaimPipeline(dedupeKey, meta);
+  const doc = await collection.findOneAndUpdate(
+    { _id: dedupeKey },
+    pipeline,
+    { upsert: true, returnDocument: "after", ...sessionOpt }
+  );
+  return doc?._pwWon === true;
+}
+async function webhookEventsMarkApplied(collection, dedupeKey, sessionOpt) {
+  await collection.updateOne({ _id: dedupeKey }, { $set: { appliedAt: /* @__PURE__ */ new Date() } }, sessionOpt);
+}
+
+// src/db/mongodb/url.ts
+var URL_SCHEMES = ["mongodb://", "mongodb+srv://"];
+function looksLikeMongoClient(value) {
+  const candidate = value;
+  return typeof candidate.connect === "function" && typeof candidate.close === "function" && typeof candidate.db === "function" && typeof candidate.startSession === "function";
+}
+function validateMongoUrl(url) {
+  if (typeof url !== "string" || url.length === 0) {
+    throw new PayweaveConfigError(
+      "payweave/db/mongodb: mongodbAdapter({ url, dbName }) requires a non-empty string url."
+    );
+  }
+  if (!URL_SCHEMES.some((scheme) => url.startsWith(scheme))) {
+    throw new PayweaveConfigError(
+      'payweave/db/mongodb: mongodbAdapter({ url, ... }) requires a "mongodb://" or "mongodb+srv://" connection string.'
+    );
+  }
+}
+function validateDbName(dbName) {
+  if (typeof dbName !== "string" || dbName.length === 0) {
+    throw new PayweaveConfigError(
+      "payweave/db/mongodb: mongodbAdapter(...) requires a non-empty `dbName` \u2014 a MongoDB connection string may name a default database in its path, but this adapter always requires `dbName` explicitly, for both { url } and { client }."
+    );
+  }
+}
+function resolveMongoInput(input) {
+  if (input === null || typeof input !== "object") {
+    throw new PayweaveConfigError(
+      `payweave/db/mongodb: mongodbAdapter(...) expects { url, dbName } (a mongodb:///mongodb+srv:// connection string) or { client, dbName } (an existing MongoClient) \u2014 got ${input === null ? "null" : typeof input}.`
+    );
+  }
+  const record = input;
+  if ("url" in record) {
+    validateMongoUrl(record.url);
+    validateDbName(record.dbName);
+    return { kind: "url", url: record.url, dbName: record.dbName };
+  }
+  if ("client" in record) {
+    const client = record.client;
+    if (client === null || typeof client !== "object" || !looksLikeMongoClient(client)) {
+      throw new PayweaveConfigError(
+        `payweave/db/mongodb: mongodbAdapter({ client, dbName }) expects \`client\` to be a MongoClient-like instance (has .connect()/.close()/.db()/.startSession()) \u2014 got ${client === null ? "null" : typeof client === "object" ? "an object missing one of those methods" : typeof client}.`
+      );
+    }
+    validateDbName(record.dbName);
+    return { kind: "client", client, dbName: record.dbName };
+  }
+  throw new PayweaveConfigError(
+    "payweave/db/mongodb: mongodbAdapter(...) expects { url, dbName } (a mongodb:///mongodb+srv:// connection string) or { client, dbName } (an existing MongoClient) \u2014 got an object matching neither shape."
+  );
+}
+
+// src/db/mongodb/index.ts
+async function connect(target) {
+  if (target.kind === "client") {
+    const client2 = target.client;
+    await target.client.connect();
+    return { client: client2, db: client2.db(target.dbName) };
+  }
+  let mod;
+  try {
+    mod = await import('mongodb');
+  } catch (cause) {
+    throw installHintError(cause);
+  }
+  const rawClient = new mod.MongoClient(target.url);
+  await rawClient.connect();
+  const client = rawClient;
+  return { client, db: client.db(target.dbName) };
+}
+function buildLazyAdapter(getConnection) {
+  let builtPromise;
+  const getReal = () => {
+    builtPromise ??= getConnection().then(
+      ({ client, db }) => buildAdapter({ client, db })
+    );
+    return builtPromise;
+  };
+  return {
+    dialect: "mongodb",
+    customers: {
+      getByExternalId: async (externalId) => (await getReal()).customers.getByExternalId(externalId),
+      upsert: async (input) => (await getReal()).customers.upsert(input),
+      linkProviderRef: async (externalId, provider, ref) => (await getReal()).customers.linkProviderRef(externalId, provider, ref)
+    },
+    plans: {
+      getActiveVersion: async (planId) => (await getReal()).plans.getActiveVersion(planId),
+      listActive: async () => (await getReal()).plans.listActive(),
+      pushVersion: async (plan) => (await getReal()).plans.pushVersion(plan)
+    },
+    subscriptions: {
+      getActive: async (customerId, group) => (await getReal()).subscriptions.getActive(customerId, group),
+      create: async (input) => (await getReal()).subscriptions.create(input),
+      update: async (id, patch) => (await getReal()).subscriptions.update(id, patch)
+    },
+    balances: {
+      get: async (customerId, featureId, group) => (await getReal()).balances.get(customerId, featureId, group),
+      consume: async (input) => (await getReal()).balances.consume(input),
+      resetTo: async (customerId, featureId, group, init) => (await getReal()).balances.resetTo(customerId, featureId, group, init)
+    },
+    webhookEvents: {
+      claim: async (dedupeKey, meta) => (await getReal()).webhookEvents.claim(dedupeKey, meta),
+      markApplied: async (dedupeKey) => (await getReal()).webhookEvents.markApplied(dedupeKey)
+    },
+    migrations: {
+      status: async () => (await getReal()).migrations.status(),
+      apply: async () => (await getReal()).migrations.apply()
+    },
+    transaction: async (fn) => (await getReal()).transaction(fn)
+  };
+}
+function mongodbAdapter(input) {
+  const target = resolveMongoInput(input);
+  let connectPromise;
+  const getConnection = () => {
+    connectPromise ??= connect(target);
+    return connectPromise;
+  };
+  return buildLazyAdapter(getConnection);
+}
+
+export { mongodbAdapter };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map