@ignex/ninox 0.1.2 → 0.1.3

package/dist/index.js

@@ -513,7 +513,10 @@ var WatchCoordinator = class {
    * Long-lived change-stream consumer for one collection. Each data change
    * invalidates the queries bound to it. On permanent "not supported" errors the
    * watcher is dropped and, if every planned stream failed, the cache falls back
-   * to the standalone ticker. Transient errors retry with backoff.
+   * to the standalone ticker. Transient errors (including resume-token expiry,
+   * rollbacks, and `invalidate` events) retry with backoff and invalidate the
+   * collection on reopen so entries missed during the outage are re-fetched —
+   * see the module doc for the full failure-semantics contract.
    */
   async watchLoop(key, ref) {
     let backoff = 0;
@@ -548,7 +551,7 @@ var WatchCoordinator = class {
           } catch {
           }
         }
-        if (/only supported on replica sets|not supported|ChangeStream/i.test(message)) {
+        if (/only supported on replica sets/i.test(message)) {
           this.markStreamFailed(key);
           return;
         }
@@ -880,6 +883,8 @@ var cacheCollectionKey = (dbName, physical) => `${dbName}${NS_SEP}${physical}`;
 var QueryCache = class {
   lru;
   index = /* @__PURE__ */ new Map();
+  /** Per-collection version — bumped on every invalidation/clear of that collection. */
+  colVersions = /* @__PURE__ */ new Map();
   ttlMs;
   clone;
   hits = 0;
@@ -914,6 +919,14 @@ var QueryCache = class {
   key(collection, filterHash) {
     return `${collection}${SEP}${filterHash}`;
   }
+  /**
+   * Current version of a collection key (db-namespaced, e.g. from
+   * `cacheCollectionKey`). Reads capture it BEFORE fetching and pass it to
+   * `set()` so a concurrent invalidation can never be hidden by a late write.
+   */
+  versionOf(collection) {
+    return this.colVersions.get(collection) ?? 0;
+  }
   get(key) {
     const entry = this.lru.get(key);
     if (!entry) {
@@ -925,22 +938,34 @@ var QueryCache = class {
       this.misses++;
       return void 0;
     }
+    if (entry.versions) {
+      for (const [col, ver] of Object.entries(entry.versions)) {
+        if (this.versionOf(col) !== ver) {
+          this.lru.delete(key);
+          this.misses++;
+          return void 0;
+        }
+      }
+    }
     this.hits++;
     return this.clone ? cloneDeep(entry.value) : entry.value;
   }
-  set(key, value, ttlMs) {
+  set(key, value, ttlMs, collections, versions) {
     this.sets++;
     const ttl = ttlMs ?? this.ttlMs;
     const expiresAt = ttl > 0 ? Date.now() + ttl : Infinity;
-    this.lru.set(key, { value, expiresAt });
+    this.lru.set(key, { value, expiresAt, versions });
     const sep = key.indexOf(SEP);
-    const collection = sep === -1 ? key : key.slice(0, sep);
-    let keys = this.index.get(collection);
-    if (!keys) {
-      keys = /* @__PURE__ */ new Set();
-      this.index.set(collection, keys);
+    const primary = sep === -1 ? key : key.slice(0, sep);
+    const collectionKeys = /* @__PURE__ */ new Set([primary, ...collections ?? []]);
+    for (const collection of collectionKeys) {
+      let keys = this.index.get(collection);
+      if (!keys) {
+        keys = /* @__PURE__ */ new Set();
+        this.index.set(collection, keys);
+      }
+      keys.add(key);
     }
-    keys.add(key);
   }
   delete(key) {
     this.deletes++;
@@ -948,6 +973,7 @@ var QueryCache = class {
   }
   /** Drop every cached entry belonging to a physical collection. */
   invalidateByCollection(collection) {
+    this.colVersions.set(collection, (this.colVersions.get(collection) ?? 0) + 1);
     const keys = this.index.get(collection);
     if (!keys) return;
     this.invalidateEvents++;
@@ -956,6 +982,9 @@ var QueryCache = class {
   }
   clear() {
     this.clearEvents++;
+    for (const collection of this.index.keys()) {
+      this.colVersions.set(collection, (this.colVersions.get(collection) ?? 0) + 1);
+    }
     this.lru.clear();
     this.index.clear();
   }
@@ -2664,28 +2693,48 @@ var PipelineBuilder = class _PipelineBuilder {
   /* ------------------------------ terminals ---------------------------- */
   /** Run the pipeline and return every output document. */
   toArray() {
+    const run = (r) => this.deps.coll().aggregate(this.stages, this.deps.mergeDriver(r.driverOpts, r.sdk)).toArray();
+    if (this.deps.cachedAggregate) {
+      return this.deps.cachedAggregate({
+        collection: this.deps.logical,
+        opName: "mongo.pipeline",
+        pipeline: this.stages,
+        options: this.deps.options,
+        execute: run
+      });
+    }
     return defineCrudOp(
       this.deps.crudDeps,
       this.deps.logical,
       "mongo.pipeline",
-      (r) => this.deps.coll().aggregate(this.stages, this.deps.mergeDriver(r.driverOpts, r.sdk)).toArray(),
+      run,
       this.deps.options
     );
   }
   /** Run the pipeline and return the first output document (or null). */
   async first() {
+    const run = async (r) => {
+      const cursor = this.deps.coll().aggregate(this.stages, this.deps.mergeDriver(r.driverOpts, r.sdk));
+      try {
+        return await cursor.tryNext();
+      } finally {
+        await cursor.close();
+      }
+    };
+    if (this.deps.cachedAggregate) {
+      return this.deps.cachedAggregate({
+        collection: this.deps.logical,
+        opName: "mongo.pipeline.first",
+        pipeline: this.stages,
+        options: this.deps.options,
+        execute: run
+      });
+    }
     return defineCrudOp(
       this.deps.crudDeps,
       this.deps.logical,
-      "mongo.pipeline",
-      async (r) => {
-        const cursor = this.deps.coll().aggregate(this.stages, this.deps.mergeDriver(r.driverOpts, r.sdk));
-        try {
-          return await cursor.tryNext();
-        } finally {
-          await cursor.close();
-        }
-      },
+      "mongo.pipeline.first",
+      run,
       this.deps.options
     );
   }
@@ -2797,7 +2846,7 @@ var buildAggregationStages = () => {
 
 // src/service/aggregation/aggregate.ts
 var makeAggregateOps = (ctx) => {
-  const { deps: deps2, coll, mergeAggOptions: mergeAggOptions2 } = ctx;
+  const { deps: deps2, coll, mergeAggOptions: mergeAggOptions2, cachedAggregate } = ctx;
   const aggregate = async (collection, pipelineBuilder, options) => {
     const stages = buildAggregationStages();
     const pipeline2 = pipelineBuilder(stages);
@@ -2814,7 +2863,8 @@ var makeAggregateOps = (ctx) => {
     coll: () => coll(collection),
     crudDeps: deps2,
     mergeDriver: mergeAggOptions2,
-    options
+    options,
+    cachedAggregate
   });
   return { aggregate, pipeline };
 };
@@ -2834,10 +2884,103 @@ var DATE_PART_FORMATS = {
   month: "%Y-%m",
   year: "%Y"
 };
+var collectAggSources = (primaryLogical, pipeline, extraLogical = []) => {
+  const sources = /* @__PURE__ */ new Set([primaryLogical, ...extraLogical]);
+  const visit = (stages) => {
+    if (!Array.isArray(stages)) return;
+    for (const stage of stages) {
+      if (!stage || typeof stage !== "object") continue;
+      const s2 = stage;
+      const lookup = s2.$lookup;
+      if (lookup && typeof lookup === "object") {
+        if (typeof lookup.from === "string") sources.add(lookup.from);
+        if (Array.isArray(lookup.pipeline)) visit(lookup.pipeline);
+      }
+      const union = s2.$unionWith;
+      if (union && typeof union === "object") {
+        if (typeof union.coll === "string") sources.add(union.coll);
+        if (Array.isArray(union.pipeline)) visit(union.pipeline);
+      }
+      const facet = s2.$facet;
+      if (facet && typeof facet === "object") {
+        for (const branch of Object.values(facet)) visit(branch);
+      }
+    }
+  };
+  visit(pipeline);
+  return [...sources];
+};
+var isCacheablePipeline = (pipeline) => {
+  for (const stage of pipeline) {
+    if (!stage || typeof stage !== "object") continue;
+    if ("$out" in stage || "$merge" in stage || "$sample" in stage) return false;
+    const s2 = stage;
+    const lookup = s2.$lookup;
+    if (lookup && Array.isArray(lookup.pipeline) && !isCacheablePipeline(lookup.pipeline)) {
+      return false;
+    }
+    const facet = s2.$facet;
+    if (facet && typeof facet === "object") {
+      for (const branch of Object.values(facet)) {
+        if (Array.isArray(branch) && !isCacheablePipeline(branch)) return false;
+      }
+    }
+  }
+  return true;
+};
+
+// src/service/aggregation/cached-read.ts
+var createCachedAggregate = (ctx) => {
+  const { client, deps: deps2, opts, resolve } = ctx;
+  const cache = opts.cache;
+  return async (input) => {
+    const { collection: collectionName, opName, pipeline, options, sources = [], execute } = input;
+    const collection = collectionName;
+    const physical = resolve(String(collection));
+    const resolved = resolveQueryOptions(options);
+    const noSession = !resolved.sdk.session;
+    const useCache = cache !== void 0 && noSession && resolved.cache !== false && isCacheablePipeline(pipeline);
+    const shouldDedupe = resolved.dedupe !== false && (resolved.dedupe === true || opts.dedupeReads === true && noSession) && opts.inFlight !== void 0;
+    const runDriver = () => defineCrudOp(deps2, collection, opName, execute, options);
+    const key = useCache ? cache.key(
+      cacheCollectionKey(client.databaseName, physical),
+      stableHash([opName, pipeline, options])
+    ) : void 0;
+    const toSourceKeys = () => collectAggSources(String(collection), pipeline, sources).map((name) => {
+      try {
+        return cacheCollectionKey(client.databaseName, resolve(name));
+      } catch {
+        return cacheCollectionKey(client.databaseName, name);
+      }
+    });
+    const runOnce = () => {
+      if (useCache && key) {
+        const sourceKeys = toSourceKeys();
+        const primaryKey = cacheCollectionKey(client.databaseName, physical);
+        const versions = { [primaryKey]: cache.versionOf(primaryKey) };
+        for (const col of sourceKeys) {
+          if (!(col in versions)) versions[col] = cache.versionOf(col);
+        }
+        const hit = cache.get(key);
+        if (hit !== void 0) return Promise.resolve(hit);
+        return runDriver().then((value) => {
+          cache.set(key, value, void 0, sourceKeys, versions);
+          return value;
+        });
+      }
+      return runDriver();
+    };
+    if (shouldDedupe) {
+      const dedupeKey = `${cacheCollectionKey(client.databaseName, physical)}|${opName}|${stableHash([pipeline, options])}`;
+      return opts.inFlight.run(dedupeKey, runOnce);
+    }
+    return runOnce();
+  };
+};
 
 // src/service/aggregation/group.ts
 var makeGroupOps = (ctx) => {
-  const { deps: deps2, coll, mergeAggOptions: mergeAggOptions2 } = ctx;
+  const { coll, mergeAggOptions: mergeAggOptions2, cachedAggregate } = ctx;
   const groupBy = async (collection, baseFilter, config, customization = {}, options) => {
     if (config.limit !== void 0 && (!Number.isFinite(config.limit) || config.limit < 0)) {
       throw new BadRequest("groupBy: `limit` must be a non-negative finite number");
@@ -2850,13 +2993,13 @@ var makeGroupOps = (ctx) => {
       ...config.limit !== void 0 ? [{ $limit: config.limit }] : [],
       ...customization.postPipeline ?? []
     ];
-    return defineCrudOp(
-      deps2,
+    return cachedAggregate({
       collection,
-      "mongo.groupBy",
-      (r) => coll(collection).aggregate(pipeline, mergeAggOptions2(r.driverOpts, r.sdk)).toArray(),
-      options
-    );
+      opName: "mongo.groupBy",
+      pipeline,
+      options,
+      execute: (r) => coll(collection).aggregate(pipeline, mergeAggOptions2(r.driverOpts, r.sdk)).toArray()
+    });
   };
   const dateRangeAnalysis = async (collection, baseFilter, dateConfig, analysisConfig = {}, customization = {}, options) => {
     if (analysisConfig.limit !== void 0 && (!Number.isFinite(analysisConfig.limit) || analysisConfig.limit < 0)) {
@@ -2880,20 +3023,20 @@ var makeGroupOps = (ctx) => {
       ...analysisConfig.limit !== void 0 ? [{ $limit: analysisConfig.limit }] : [],
       ...customization.postPipeline ?? []
     ];
-    return defineCrudOp(
-      deps2,
+    return cachedAggregate({
       collection,
-      "mongo.dateRangeAnalysis",
-      (r) => coll(collection).aggregate(pipeline, mergeAggOptions2(r.driverOpts, r.sdk)).toArray(),
-      options
-    );
+      opName: "mongo.dateRangeAnalysis",
+      pipeline,
+      options,
+      execute: (r) => coll(collection).aggregate(pipeline, mergeAggOptions2(r.driverOpts, r.sdk)).toArray()
+    });
   };
   return { groupBy, dateRangeAnalysis };
 };
 
 // src/service/aggregation/lookup-join.ts
 var makeLookupJoinOp = (ctx) => {
-  const { deps: deps2, coll, mergeAggOptions: mergeAggOptions2, resolve } = ctx;
+  const { coll, mergeAggOptions: mergeAggOptions2, resolve, cachedAggregate } = ctx;
   const lookupJoin = async (collection, baseFilter, lookups, customization = {}, options) => {
     const pipeline = [
       ...customization.prePipeline ?? [],
@@ -2912,13 +3055,15 @@ var makeLookupJoinOp = (ctx) => {
       })),
       ...customization.postPipeline ?? []
     ];
-    return defineCrudOp(
-      deps2,
+    return cachedAggregate({
       collection,
-      "mongo.lookupJoin",
-      (r) => coll(collection).aggregate(pipeline, mergeAggOptions2(r.driverOpts, r.sdk)).toArray(),
-      options
-    );
+      opName: "mongo.lookupJoin",
+      pipeline,
+      options,
+      // Writes to any joined collection must invalidate the cached join.
+      sources: lookups.map((l) => l.fromCollection),
+      execute: (r) => coll(collection).aggregate(pipeline, mergeAggOptions2(r.driverOpts, r.sdk)).toArray()
+    });
   };
   return { lookupJoin };
 };
@@ -2985,7 +3130,7 @@ var buildSearchStages = (baseFilter, searchConfig) => searchConfig.useRegex ? bu
 
 // src/service/aggregation/text-search.ts
 var makeTextSearchOp = (ctx) => {
-  const { deps: deps2, coll, mergeAggOptions: mergeAggOptions2 } = ctx;
+  const { coll, mergeAggOptions: mergeAggOptions2, cachedAggregate } = ctx;
   const textSearch = async (collection, baseFilter, searchConfig, paginationConfig = {}, customization = {}, options) => {
     const normalized = normalizePageLimit(
       { page: paginationConfig.page, limit: paginationConfig.limit },
@@ -3011,19 +3156,19 @@ var makeTextSearchOp = (ctx) => {
         }
       }
     ];
-    return defineCrudOp(
-      deps2,
+    return cachedAggregate({
       collection,
-      "mongo.textSearch",
-      async (r) => {
+      opName: "mongo.textSearch",
+      pipeline,
+      options,
+      execute: async (r) => {
         const rows = await coll(collection).aggregate(pipeline, mergeAggOptions2(r.driverOpts, r.sdk)).toArray();
         const row = rows[0];
         const data = row?.data ?? [];
         const totalCount = row?.totalCount?.[0]?.count ?? 0;
         return buildPaginationResult(data, totalCount, normalized.page, normalized.limit);
-      },
-      options
-    );
+      }
+    });
   };
   return { textSearch };
 };
@@ -3037,7 +3182,8 @@ var makeAggregationOps = (client, dbLabel, logger, opts) => {
     resolve,
     deps: deps2,
     coll,
-    mergeAggOptions
+    mergeAggOptions,
+    cachedAggregate: createCachedAggregate({ client, deps: deps2, opts, resolve })
   };
   return {
     ...makeAggregateOps(ctx),
@@ -3155,10 +3301,12 @@ var createCrudContext = (client, dbLabel, logger, opts) => {
     });
     const runOnce = () => {
       if (useCache && key) {
+        const colKey = cacheCollectionKey(client.databaseName, physical);
+        const versions = { [colKey]: opts.cache.versionOf(colKey) };
         const hit = opts.cache.get(key);
         if (hit !== void 0) return Promise.resolve(hit);
         return fetchAndCheck().then((value) => {
-          opts.cache.set(key, value);
+          opts.cache.set(key, value, void 0, void 0, versions);
           return value;
         });
       }
@@ -3930,7 +4078,7 @@ var makePaginateCursor = (ctx) => {
 
 // src/service/pagination/offset.ts
 var makePaginateFlexible = (ctx) => {
-  const { client, dbLabel, logger, opts, resolve, deps: deps2 } = ctx;
+  const { client, dbLabel, logger, opts, resolve, cachedAggregate } = ctx;
   const paginateFlexible = async (collection, baseFilter, config = {}) => {
     const normalized = normalizePageLimit(
       { page: config.page, limit: config.limit },
@@ -3952,11 +4100,12 @@ var makePaginateFlexible = (ctx) => {
         }
       }
     ];
-    return defineCrudOp(
-      deps2,
+    return cachedAggregate({
       collection,
-      "mongo.paginateFlexible",
-      async (r) => {
+      opName: "mongo.paginateFlexible",
+      pipeline,
+      options: config.queryOptions,
+      execute: async (r) => {
         const aggOptions = {
           ...r.driverOpts,
           session: r.sdk.session,
@@ -3980,9 +4129,8 @@ var makePaginateFlexible = (ctx) => {
           data
         );
         return buildPaginationResult(data, totalCount, normalized.page, normalized.limit);
-      },
-      config.queryOptions
-    );
+      }
+    });
   };
   return { paginateFlexible };
 };
@@ -3997,7 +4145,8 @@ var makePaginationOps = (client, dbLabel, logger, opts) => {
     logger,
     opts,
     resolve,
-    deps: deps2
+    deps: deps2,
+    cachedAggregate: createCachedAggregate({ client, deps: deps2, opts, resolve })
   };
   return {
     ...makePaginateFlexible(ctx),
@@ -4186,11 +4335,17 @@ var buildManager = (deps2, dbKey, dbName, client) => {
     resolveCollectionName,
     wrapMongoErrors: deps2.wrapMongoErrors,
     drift: deps2.drift,
-    getSchema: (logical) => getDefinition(logical)?.schema
+    getSchema: (logical) => getDefinition(logical)?.schema,
+    cache: sharedCache,
+    dedupeReads,
+    inFlight
   });
   const aggregation = makeAggregationOps(handle, dbName, logger, {
     resolveCollectionName,
-    wrapMongoErrors: deps2.wrapMongoErrors
+    wrapMongoErrors: deps2.wrapMongoErrors,
+    cache: sharedCache,
+    dedupeReads,
+    inFlight
   });
   const schema = makeSchemaOps(handle, logger, { resolveCollectionName, getDefinition });
   const transactionOps = makeTransactionOps(client, handle, logger, config, {