@break-limits/mongoose-cache 0.1.0

package/dist/index.js

@@ -0,0 +1,911 @@
+// src/plugins/createCache.ts
+import { EventEmitter } from "events";
+
+// src/cache/RedisCacheStore.ts
+var RedisCacheStore = class {
+  constructor(redis, versionPrefix = "ver:") {
+    this.redis = redis;
+    this.versionPrefix = versionPrefix;
+  }
+  redis;
+  versionPrefix;
+  async get(key) {
+    return this.redis.getBuffer(key);
+  }
+  async set(key, value, ttlMs) {
+    if (ttlMs !== void 0) {
+      await this.redis.set(key, value, "PX", ttlMs);
+    } else {
+      await this.redis.set(key, value);
+    }
+  }
+  async del(keys) {
+    if (keys.length === 0) return;
+    await this.redis.del(...keys);
+  }
+  async getVersion(model) {
+    const raw = await this.redis.get(this.versionKey(model));
+    return raw === null ? 0 : Number(raw);
+  }
+  async bumpVersion(model) {
+    return this.redis.incr(this.versionKey(model));
+  }
+  async addToSet(setKey, member) {
+    await this.redis.sadd(setKey, member);
+  }
+  async drainSet(setKey) {
+    const members = await this.redis.smembers(setKey);
+    if (members.length > 0) await this.redis.del(setKey);
+    return members;
+  }
+  versionKey(model) {
+    return `${this.versionPrefix}${model}`;
+  }
+};
+
+// src/cache/Serializer.ts
+import { BSON } from "bson";
+function serialize(value) {
+  const encoded = BSON.serialize({ v: value });
+  return Buffer.from(encoded);
+}
+function deserialize(buffer) {
+  const decoded = BSON.deserialize(buffer, {
+    promoteBuffers: true,
+    promoteValues: true
+  });
+  return decoded.v;
+}
+
+// src/invalidation/RedisDependencyIndex.ts
+var RedisDependencyIndex = class {
+  constructor(redis, prefix = "idx:") {
+    this.redis = redis;
+    this.prefix = prefix;
+  }
+  redis;
+  prefix;
+  async addQuery(model, queryKey, meta) {
+    await this.redis.sadd(this.setKey(model), queryKey);
+    await this.redis.set(this.metaKey(model, queryKey), serialize(meta));
+  }
+  async removeQuery(model, queryKey) {
+    await this.redis.srem(this.setKey(model), queryKey);
+    await this.redis.del(this.metaKey(model, queryKey));
+  }
+  async getQueries(model) {
+    const queryKeys = await this.redis.smembers(this.setKey(model));
+    const queries = [];
+    for (const queryKey of queryKeys) {
+      const raw = await this.redis.getBuffer(this.metaKey(model, queryKey));
+      if (raw === null) continue;
+      const meta = deserialize(raw);
+      queries.push({ queryKey, ...meta });
+    }
+    return queries;
+  }
+  async clearModel(model) {
+    const queryKeys = await this.redis.smembers(this.setKey(model));
+    if (queryKeys.length === 0) return [];
+    await this.redis.del(
+      this.setKey(model),
+      ...queryKeys.map((qk) => this.metaKey(model, qk))
+    );
+    return queryKeys;
+  }
+  setKey(model) {
+    return `${this.prefix}qset:${model}`;
+  }
+  metaKey(model, queryKey) {
+    return `${this.prefix}qmeta:${model}:${queryKey}`;
+  }
+};
+
+// src/cache/fingerprint.ts
+function normalizeQuery(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (isObjectIdLike(value)) {
+    return { $oid: value.toHexString() };
+  }
+  if (value instanceof Date) {
+    return { $date: value.toISOString() };
+  }
+  if (value instanceof RegExp) {
+    return { $regex: value.source, $options: value.flags };
+  }
+  if (Array.isArray(value)) {
+    return value.map((el) => normalizeQuery(el));
+  }
+  const out = {};
+  for (const key of Object.keys(value).sort()) {
+    out[key] = normalizeQuery(value[key]);
+  }
+  return out;
+}
+function isObjectIdLike(value) {
+  return value._bsontype === "ObjectId" && typeof value.toHexString === "function";
+}
+
+// src/invalidation/PredicateMatcher.ts
+var LOGICAL_OPERATORS = /* @__PURE__ */ new Set(["$and", "$or", "$nor"]);
+var FIELD_OPERATORS = /* @__PURE__ */ new Set([
+  "$eq",
+  "$ne",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$in",
+  "$nin",
+  "$exists",
+  "$not"
+]);
+function matches(filter, doc) {
+  for (const [key, condition] of Object.entries(filter)) {
+    if (key === "$and") {
+      if (!condition.every((sub) => matches(sub, doc))) return false;
+    } else if (key === "$or") {
+      if (!condition.some((sub) => matches(sub, doc))) return false;
+    } else if (key === "$nor") {
+      if (condition.some((sub) => matches(sub, doc))) return false;
+    } else {
+      const resolved = resolvePath(doc, key);
+      if (!fieldMatches(resolved, condition)) return false;
+    }
+  }
+  return true;
+}
+function resolvePath(doc, path) {
+  const segments = path.split(".");
+  let current = doc;
+  for (const seg of segments) {
+    if (current === null || typeof current !== "object" || Array.isArray(current)) {
+      return { exists: false, value: void 0 };
+    }
+    if (!(seg in current)) {
+      return { exists: false, value: void 0 };
+    }
+    current = current[seg];
+  }
+  return { exists: true, value: current };
+}
+function isOperatorObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && Object.keys(value).length > 0 && Object.keys(value).every((k) => k.startsWith("$"));
+}
+function fieldMatches(resolved, condition) {
+  if (isOperatorObject(condition)) {
+    return Object.entries(condition).every(
+      ([op, operand]) => operatorMatches(resolved, op, operand)
+    );
+  }
+  return equals(resolved, condition);
+}
+function operatorMatches(resolved, op, operand) {
+  switch (op) {
+    case "$eq":
+      return equals(resolved, operand);
+    case "$ne":
+      return !equals(resolved, operand);
+    case "$in":
+      return operand.some((o) => equals(resolved, o));
+    case "$nin":
+      return !operand.some((o) => equals(resolved, o));
+    case "$exists":
+      return resolved.exists === operand;
+    case "$not":
+      return !fieldMatches(resolved, operand);
+    case "$gt":
+    case "$gte":
+    case "$lt":
+    case "$lte":
+      return compare(resolved.value, op, operand);
+    default:
+      return false;
+  }
+}
+function equals(resolved, target) {
+  if (target === null) {
+    return !resolved.exists || resolved.value === null;
+  }
+  if (!resolved.exists) return false;
+  const fv = resolved.value;
+  if (Array.isArray(fv) && fv.some((el) => scalarEquals(el, target))) {
+    return true;
+  }
+  return scalarEquals(fv, target);
+}
+function scalarEquals(a, b) {
+  if (a === b) return true;
+  return canonical(a) === canonical(b);
+}
+function canonical(value) {
+  return JSON.stringify(normalizeQuery(value));
+}
+function compare(fieldValue, op, operand) {
+  if (Array.isArray(fieldValue)) {
+    return fieldValue.some((el) => compareScalar(el, op, operand));
+  }
+  return compareScalar(fieldValue, op, operand);
+}
+function compareScalar(a, op, b) {
+  const left = toComparable(a);
+  const right = toComparable(b);
+  if (left === null || right === null || typeof left !== typeof right) {
+    return false;
+  }
+  switch (op) {
+    case "$gt":
+      return left > right;
+    case "$gte":
+      return left >= right;
+    case "$lt":
+      return left < right;
+    case "$lte":
+      return left <= right;
+    default:
+      return false;
+  }
+}
+function toComparable(value) {
+  if (typeof value === "number" || typeof value === "string") return value;
+  if (value instanceof Date) return value.getTime();
+  return null;
+}
+function isSupportedPredicate(filter) {
+  if (typeof filter !== "object" || filter === null || Array.isArray(filter)) {
+    return false;
+  }
+  for (const [key, condition] of Object.entries(filter)) {
+    if (LOGICAL_OPERATORS.has(key)) {
+      if (!Array.isArray(condition)) return false;
+      if (!condition.every((sub) => isSupportedPredicate(sub))) return false;
+    } else if (key.startsWith("$")) {
+      return false;
+    } else if (!isSupportedCondition(condition)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isSupportedCondition(condition) {
+  if (condition instanceof RegExp) return false;
+  if (isOperatorObject(condition)) {
+    return Object.entries(condition).every(([op, operand]) => {
+      if (!FIELD_OPERATORS.has(op)) return false;
+      if (op === "$not") return isOperatorObject(operand) && isSupportedCondition(operand);
+      if (op === "$in" || op === "$nin") {
+        return Array.isArray(operand) && !operand.some((el) => el instanceof RegExp);
+      }
+      if (op === "$exists") return typeof operand === "boolean";
+      return true;
+    });
+  }
+  return true;
+}
+
+// src/utils/id.ts
+function idToString(id) {
+  if (id === null || id === void 0) return void 0;
+  if (typeof id === "string") return id;
+  if (typeof id === "number") return String(id);
+  if (id instanceof Date) return id.toISOString();
+  if (typeof id === "object" && id._bsontype === "ObjectId" && typeof id.toHexString === "function") {
+    return id.toHexString();
+  }
+  return String(id);
+}
+
+// src/invalidation/InvalidationEngine.ts
+var InvalidationEngine = class {
+  constructor(index) {
+    this.index = index;
+  }
+  index;
+  async registerQuery(model, queryKey, meta) {
+    await this.index.addQuery(model, queryKey, meta);
+  }
+  async onWrite(model, before, after) {
+    const docId = idToString((after ?? before)?._id);
+    const queries = await this.index.getQueries(model);
+    const invalidated = [];
+    for (const q of queries) {
+      const directHit = docId !== void 0 && q.resultDocIds.includes(docId);
+      const wasMatch = before !== null && matches(q.predicate, before);
+      const nowMatch = after !== null && matches(q.predicate, after);
+      const transition = wasMatch !== nowMatch;
+      const limitedHit = q.limited && (wasMatch || nowMatch);
+      if (directHit || transition || limitedHit) {
+        invalidated.push(q.queryKey);
+        await this.index.removeQuery(model, q.queryKey);
+      }
+    }
+    return { invalidatedQueryKeys: invalidated };
+  }
+  /**
+   * Remove every registered query for a model and return their cache keys.
+   * Used as a conservative fallback (bulkWrite, upserts) where per-document
+   * before/after images aren't available.
+   */
+  async clearQueries(model) {
+    return this.index.clearModel(model);
+  }
+};
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function stableHash(value) {
+  const canonical2 = JSON.stringify(normalizeQuery(value));
+  return createHash("sha256").update(canonical2 ?? "undefined").digest("hex").slice(0, 32);
+}
+
+// src/cache/CacheKey.ts
+function tenantPrefix(tenant) {
+  return tenant ? `tenant:${tenant}:` : "";
+}
+function buildQueryKey(input) {
+  const hash = stableHash({
+    op: input.op,
+    filter: input.filter ?? null,
+    projection: input.projection ?? null,
+    sort: input.sort ?? null,
+    skip: input.skip ?? null,
+    limit: input.limit ?? null,
+    populate: input.populate ?? null,
+    collation: input.collation ?? null,
+    distinct: input.distinct ?? null,
+    schemaVersion: input.schemaVersion ?? null
+  });
+  return `${tenantPrefix(input.tenant)}q:${input.model}:${hash}`;
+}
+function buildDocKey(model, id, tenant) {
+  return `${tenantPrefix(tenant)}doc:${model}:${id}`;
+}
+function buildTagKey(collection) {
+  return `tag:coll:${collection}`;
+}
+function buildAggregateKey(model, pipeline, tenant) {
+  return `${tenantPrefix(tenant)}agg:${model}:${stableHash(pipeline)}`;
+}
+
+// src/cache/CacheManager.ts
+var CacheManager = class {
+  constructor(store, engine, events) {
+    this.store = store;
+    this.engine = engine;
+    this.events = events;
+  }
+  store;
+  engine;
+  events;
+  inflight = /* @__PURE__ */ new Map();
+  /**
+   * Return the cached value for a query, or load it via `loader`, cache it
+   * (when safe), and register it for precise invalidation.
+   *
+   * @param extractIds maps a loaded result to the stable string ids of the
+   *   documents it contains — required for T1 direct-membership invalidation.
+   */
+  async getOrLoad(query, loader, extractIds2 = () => []) {
+    if (query.tier === "T4") return loader();
+    let cached = null;
+    try {
+      cached = await this.store.get(query.key);
+    } catch (err) {
+      this.emitError(err);
+      return loader();
+    }
+    if (cached !== null) {
+      this.events?.emit("hit", { key: query.key, model: query.model });
+      return deserialize(cached);
+    }
+    this.events?.emit("miss", { key: query.key, model: query.model });
+    const existing = this.inflight.get(query.key);
+    if (existing) return existing;
+    const work = this.loadAndCache(query, loader, extractIds2);
+    this.inflight.set(query.key, work);
+    try {
+      return await work;
+    } finally {
+      this.inflight.delete(query.key);
+    }
+  }
+  async loadAndCache(query, loader, extractIds2) {
+    let versionBefore;
+    try {
+      versionBefore = await this.store.getVersion(query.model);
+    } catch (err) {
+      this.emitError(err);
+      return loader();
+    }
+    const result = await loader();
+    let versionAfter;
+    try {
+      versionAfter = await this.store.getVersion(query.model);
+    } catch (err) {
+      this.emitError(err);
+      return result;
+    }
+    if (versionBefore !== versionAfter) {
+      return result;
+    }
+    try {
+      await this.store.set(query.key, serialize(result), query.ttlMs);
+      if (query.predicate) {
+        await this.engine.registerQuery(query.model, query.key, {
+          predicate: query.predicate,
+          limited: query.limited ?? false,
+          resultDocIds: extractIds2(result)
+        });
+      }
+      for (const tag of query.tags ?? []) {
+        await this.store.addToSet(buildTagKey(tag), query.key);
+      }
+    } catch (err) {
+      this.emitError(err);
+    }
+    return result;
+  }
+  /**
+   * Apply a write: bump the model version (closing the race window), run the
+   * invalidation engine, and delete every affected cache key.
+   */
+  async onWrite(model, before, after, extraKeys = []) {
+    try {
+      await this.store.bumpVersion(model);
+      const report = await this.engine.onWrite(model, before, after);
+      const keys = [...report.invalidatedQueryKeys, ...extraKeys];
+      if (keys.length > 0) {
+        await this.store.del(keys);
+        this.events?.emit("invalidate", { model, keys });
+      }
+      return keys;
+    } catch (err) {
+      this.emitError(err);
+      return [];
+    }
+  }
+  /**
+   * Conservative invalidation: drain a collection's tag and delete every
+   * entry tagged with it (T2/T3/distinct/populate). Degrade-safe.
+   */
+  async invalidateCollection(collection) {
+    try {
+      const keys = await this.store.drainSet(buildTagKey(collection));
+      if (keys.length > 0) {
+        await this.store.del(keys);
+        this.events?.emit("invalidate", { collection, keys });
+      }
+      return keys;
+    } catch (err) {
+      this.emitError(err);
+      return [];
+    }
+  }
+  /**
+   * Nuclear precise fallback: remove every registered T1 query for a model and
+   * delete its cache keys. Used for writes we cannot image (bulkWrite, upserts).
+   */
+  async flushModelPrecise(model) {
+    try {
+      const keys = await this.engine.clearQueries(model);
+      if (keys.length > 0) {
+        await this.store.del(keys);
+        this.events?.emit("invalidate", { model, keys });
+      }
+      return keys;
+    } catch (err) {
+      this.emitError(err);
+      return [];
+    }
+  }
+  /**
+   * Emit an `error` event without crashing: a bare `error` emit on an
+   * EventEmitter with no listeners would itself throw.
+   */
+  emitError(err) {
+    if (this.events && this.events.listenerCount("error") > 0) {
+      this.events.emit("error", err);
+    }
+  }
+};
+
+// src/invalidation/TierClassifier.ts
+function classifyQuery(input) {
+  if (input.hasSession || input.isCursor) return "T4";
+  if (input.op === "aggregate") return "T3";
+  if (input.op === "estimatedDocumentCount") return "T2";
+  if (input.op === "findById") return "T0";
+  const filter = input.filter ?? {};
+  if ((input.op === "find" || input.op === "findOne") && isPointRead(filter)) {
+    return "T0";
+  }
+  return isSupportedPredicate(filter) ? "T1" : "T2";
+}
+function isPointRead(filter) {
+  const keys = Object.keys(filter);
+  if (keys.length !== 1 || keys[0] !== "_id") return false;
+  const value = filter._id;
+  if (isOperatorObject2(value)) {
+    const opKeys = Object.keys(value);
+    return opKeys.length === 1 && opKeys[0] === "$in" && Array.isArray(value.$in);
+  }
+  return true;
+}
+function isOperatorObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && Object.keys(value).length > 0 && Object.keys(value).every((k) => k.startsWith("$"));
+}
+
+// src/plugins/createCache.ts
+var CACHE_OPS = /* @__PURE__ */ new Set([
+  "find",
+  "findOne",
+  "countDocuments",
+  "distinct",
+  "estimatedDocumentCount"
+]);
+var UPDATE_OPS = /* @__PURE__ */ new Set([
+  "updateOne",
+  "updateMany",
+  "findOneAndUpdate",
+  "replaceOne",
+  "findOneAndReplace"
+]);
+var DELETE_OPS = /* @__PURE__ */ new Set([
+  "deleteOne",
+  "deleteMany",
+  "findOneAndDelete"
+]);
+function createCache(options) {
+  const { mongoose } = options;
+  const emitter = new EventEmitter();
+  const store = options.store ?? new RedisCacheStore(options.redis);
+  const index = new RedisDependencyIndex(options.redis);
+  const engine = new InvalidationEngine(index);
+  const manager = new CacheManager(store, engine, emitter);
+  const registry = /* @__PURE__ */ new Map();
+  const modelNames = options.models ? Object.keys(options.models) : mongoose.modelNames();
+  for (const name of modelNames) {
+    registry.set(name, options.models?.[name] ?? {});
+  }
+  const bypass = /* @__PURE__ */ new WeakSet();
+  const tenant = () => options.tenant?.();
+  const ttlFor = (config) => config.ttlMs ?? options.defaults?.ttlMs;
+  const collectionOf = (model) => model.collection.collectionName;
+  async function fetchMatching(model, filter) {
+    const q = model.find(filter).lean();
+    bypass.add(q);
+    return await q.exec();
+  }
+  async function fetchById(model, id) {
+    const q = model.findOne({ _id: id }).lean();
+    bypass.add(q);
+    return await q.exec();
+  }
+  async function invalidateWrite(model, pairs, opts = {}) {
+    const modelName = model.modelName;
+    if (pairs.length === 0) {
+      await manager.onWrite(modelName, null, null);
+    } else {
+      for (const { before, after } of pairs) {
+        await manager.onWrite(modelName, before, after);
+      }
+    }
+    if (opts.flushPrecise) await manager.flushModelPrecise(modelName);
+    await manager.invalidateCollection(collectionOf(model));
+  }
+  async function handleRead(query, op, config) {
+    const filter = query.getFilter() ?? {};
+    const opts = query.getOptions() ?? {};
+    const tier = classifyQuery({ op, filter, hasSession: !!opts.session });
+    if (tier === "T4") return originalExec.apply(query, []);
+    const model = query.model;
+    const collection = collectionOf(model);
+    const populatePaths = Object.keys(query._mongooseOptions?.populate ?? {});
+    const hasPopulate = populatePaths.length > 0;
+    const conservative = op === "distinct" || op === "estimatedDocumentCount" || hasPopulate || tier === "T2";
+    let tags;
+    if (conservative) {
+      tags = [collection];
+      if (hasPopulate) {
+        const popCols = resolvePopulateCollections(query, populatePaths);
+        if (popCols === null) return originalExec.apply(query, []);
+        tags = [collection, ...popCols];
+      }
+    }
+    const lean = !!query._mongooseOptions?.lean;
+    const key = buildQueryKey({
+      model: model.modelName,
+      op,
+      filter,
+      projection: query.projection?.() ?? null,
+      sort: opts.sort ?? null,
+      skip: opts.skip,
+      limit: opts.limit,
+      populate: hasPopulate ? populatePaths : null,
+      distinct: query._distinct ?? null,
+      tenant: tenant()
+    });
+    const cached = {
+      key,
+      model: model.modelName,
+      tier,
+      predicate: conservative ? void 0 : filter,
+      limited: opts.limit !== void 0 && opts.limit !== null,
+      tags,
+      ttlMs: ttlFor(config)
+    };
+    const plain = await manager.getOrLoad(
+      cached,
+      async () => toPlain(await originalExec.apply(query, [])),
+      extractIds
+    );
+    return lean || hasPopulate ? plain : rehydrate(model, op, plain);
+  }
+  async function handleWrite(query, op) {
+    const model = query.model;
+    const filter = query.getFilter() ?? {};
+    const opts = query.getOptions() ?? {};
+    const beforeDocs = await fetchMatching(model, filter);
+    const result = await originalExec.apply(query, []);
+    const isDelete = DELETE_OPS.has(op);
+    const pairs = [];
+    for (const before of beforeDocs) {
+      const after = isDelete ? null : await fetchById(model, before._id);
+      pairs.push({ before, after });
+    }
+    const flushPrecise = !!opts.upsert && beforeDocs.length === 0;
+    await invalidateWrite(model, pairs, { flushPrecise });
+    return result;
+  }
+  const queryProto = mongoose.Query.prototype;
+  const originalExec = queryProto.exec;
+  function wrappedExec(...args) {
+    if (bypass.has(this)) return originalExec.apply(this, args);
+    const config = this.model ? registry.get(this.model.modelName) : void 0;
+    if (!config || config.enabled === false) return originalExec.apply(this, args);
+    const op = this.op;
+    if (CACHE_OPS.has(op)) return handleRead(this, op, config);
+    if (UPDATE_OPS.has(op) || DELETE_OPS.has(op)) return handleWrite(this, op);
+    return originalExec.apply(this, args);
+  }
+  queryProto.exec = wrappedExec;
+  const restores = [
+    () => {
+      queryProto.exec = originalExec;
+    }
+  ];
+  const aggProto = mongoose.Aggregate.prototype;
+  const originalAggExec = aggProto.exec;
+  async function handleAggregate(agg, config) {
+    const model = agg._model;
+    const pipeline = typeof agg.pipeline === "function" ? agg.pipeline() : agg._pipeline ?? [];
+    if (hasWriteStage(pipeline) || agg.options?.session) {
+      return originalAggExec.apply(agg, []);
+    }
+    const tags = collectionsInPipeline(model, pipeline);
+    const cached = {
+      key: buildAggregateKey(model.modelName, pipeline, tenant()),
+      model: model.modelName,
+      tier: "T3",
+      tags,
+      ttlMs: ttlFor(config)
+    };
+    return manager.getOrLoad(cached, async () => originalAggExec.apply(agg, []));
+  }
+  aggProto.exec = function wrappedAggExec(...args) {
+    const config = this._model ? registry.get(this._model.modelName) : void 0;
+    if (!config || config.enabled === false) return originalAggExec.apply(this, args);
+    return handleAggregate(this, config);
+  };
+  restores.push(() => {
+    aggProto.exec = originalAggExec;
+  });
+  for (const name of registry.keys()) {
+    const model = mongoose.models[name];
+    if (!model) continue;
+    const proto = model.prototype;
+    const saving = /* @__PURE__ */ new WeakSet();
+    const makePatched = (original) => async function patchedSave(...a) {
+      if (saving.has(this)) return original.apply(this, a);
+      saving.add(this);
+      try {
+        const isNew = this.isNew;
+        const before = isNew ? null : await fetchById(model, this._id);
+        const res = await original.apply(this, a);
+        const after = this.toObject();
+        await invalidateWrite(model, [{ before, after }]);
+        return res;
+      } finally {
+        saving.delete(this);
+      }
+    };
+    const originalSave = proto.save;
+    proto.save = makePatched(originalSave);
+    restores.push(() => {
+      proto.save = originalSave;
+    });
+    if (typeof proto.$save === "function") {
+      const original$save = proto.$save;
+      proto.$save = makePatched(original$save);
+      restores.push(() => {
+        proto.$save = original$save;
+      });
+    }
+    const originalInsertMany = model.insertMany.bind(model);
+    model.insertMany = async function patchedInsertMany(...a) {
+      const res = await originalInsertMany(...a);
+      const docs = Array.isArray(res) ? res : [res];
+      await invalidateWrite(
+        model,
+        docs.map((d) => ({
+          before: null,
+          after: typeof d?.toObject === "function" ? d.toObject() : d
+        }))
+      );
+      return res;
+    };
+    restores.push(() => {
+      model.insertMany = originalInsertMany;
+    });
+    const originalBulkWrite = model.bulkWrite.bind(model);
+    model.bulkWrite = async function patchedBulkWrite(...a) {
+      const res = await originalBulkWrite(...a);
+      await invalidateWrite(model, [], { flushPrecise: true });
+      return res;
+    };
+    restores.push(() => {
+      model.bulkWrite = originalBulkWrite;
+    });
+  }
+  emitter.close = () => {
+    for (const restore of restores) restore();
+  };
+  return emitter;
+}
+function hasWriteStage(pipeline) {
+  return pipeline.some((s) => s && (s.$out !== void 0 || s.$merge !== void 0));
+}
+function collectionsInPipeline(model, pipeline) {
+  const cols = /* @__PURE__ */ new Set([model.collection.collectionName]);
+  for (const stage of pipeline) {
+    if (!stage) continue;
+    if (stage.$lookup?.from) cols.add(stage.$lookup.from);
+    if (stage.$graphLookup?.from) cols.add(stage.$graphLookup.from);
+    if (stage.$unionWith) {
+      cols.add(
+        typeof stage.$unionWith === "string" ? stage.$unionWith : stage.$unionWith.coll
+      );
+    }
+  }
+  return [...cols];
+}
+function resolvePopulateCollections(query, paths) {
+  const pop = query._mongooseOptions?.populate ?? {};
+  const cols = [];
+  for (const path of paths) {
+    const opt = pop[path] ?? {};
+    let ref = opt.model;
+    if (typeof ref !== "string") {
+      const sp = query.model.schema.path(path);
+      ref = sp?.options?.ref ?? sp?.caster?.options?.ref;
+    }
+    if (typeof ref !== "string") return null;
+    const refModel = query.model.db.models[ref];
+    if (!refModel) return null;
+    cols.push(refModel.collection.collectionName);
+  }
+  return cols;
+}
+function toPlain(result) {
+  if (Array.isArray(result)) return result.map((d) => toPlainDoc(d));
+  return toPlainDoc(result);
+}
+function toPlainDoc(doc) {
+  if (doc && typeof doc.toObject === "function") {
+    return doc.toObject();
+  }
+  return doc;
+}
+function rehydrate(model, op, plain) {
+  if (op === "find") return plain.map((o) => model.hydrate(o));
+  if (op === "findOne") return plain ? model.hydrate(plain) : null;
+  return plain;
+}
+function extractIds(plain) {
+  const collect = (d) => d && typeof d === "object" && "_id" in d ? idToString(d._id) : void 0;
+  if (Array.isArray(plain)) {
+    return plain.map(collect).filter((s) => s !== void 0);
+  }
+  const single = collect(plain);
+  return single ? [single] : [];
+}
+
+// src/cache/CacheStore.ts
+var InMemoryCacheStore = class {
+  data = /* @__PURE__ */ new Map();
+  versions = /* @__PURE__ */ new Map();
+  sets = /* @__PURE__ */ new Map();
+  async get(key) {
+    return this.data.get(key) ?? null;
+  }
+  async set(key, value, _ttlMs) {
+    this.data.set(key, value);
+  }
+  async del(keys) {
+    for (const key of keys) this.data.delete(key);
+  }
+  async getVersion(model) {
+    return this.versions.get(model) ?? 0;
+  }
+  async bumpVersion(model) {
+    const next = (this.versions.get(model) ?? 0) + 1;
+    this.versions.set(model, next);
+    return next;
+  }
+  async addToSet(setKey, member) {
+    let set = this.sets.get(setKey);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.sets.set(setKey, set);
+    }
+    set.add(member);
+  }
+  async drainSet(setKey) {
+    const set = this.sets.get(setKey);
+    if (!set) return [];
+    this.sets.delete(setKey);
+    return [...set];
+  }
+};
+
+// src/invalidation/DependencyIndex.ts
+var InMemoryDependencyIndex = class {
+  byModel = /* @__PURE__ */ new Map();
+  async addQuery(model, queryKey, meta) {
+    let queries = this.byModel.get(model);
+    if (!queries) {
+      queries = /* @__PURE__ */ new Map();
+      this.byModel.set(model, queries);
+    }
+    queries.set(queryKey, meta);
+  }
+  async removeQuery(model, queryKey) {
+    this.byModel.get(model)?.delete(queryKey);
+  }
+  async getQueries(model) {
+    const queries = this.byModel.get(model);
+    if (!queries) return [];
+    return [...queries.entries()].map(([queryKey, meta]) => ({
+      queryKey,
+      ...meta
+    }));
+  }
+  async clearModel(model) {
+    const queries = this.byModel.get(model);
+    if (!queries) return [];
+    const keys = [...queries.keys()];
+    this.byModel.delete(model);
+    return keys;
+  }
+};
+export {
+  CacheManager,
+  InMemoryCacheStore,
+  InMemoryDependencyIndex,
+  InvalidationEngine,
+  RedisCacheStore,
+  RedisDependencyIndex,
+  buildDocKey,
+  buildQueryKey,
+  classifyQuery,
+  createCache,
+  deserialize,
+  isSupportedPredicate,
+  matches,
+  normalizeQuery,
+  serialize,
+  stableHash
+};
+//# sourceMappingURL=index.js.map