@remnic/core 9.3.654 → 9.3.655

package/src/namespaces/search.test.ts

@@ -13,6 +13,12 @@ type CollectionState = "present" | "missing" | "unknown" | "skipped";
 
 class FakeBackend implements SearchBackend {
   updates = 0;
+  strictUpdates = 0;
+  strictCollectionUpdates: string[] = [];
+  embeds = 0;
+  collectionEmbeds: string[] = [];
+  strictEmbeds = 0;
+  strictCollectionEmbeds: string[] = [];
   disposed = 0;
   available = true;
   calls: Array<{
@@ -130,15 +136,35 @@ class FakeBackend implements SearchBackend {
     this.updates += 1;
   }
 
+  async updateStrict(): Promise<void> {
+    this.strictUpdates += 1;
+  }
+
   async updateCollection(): Promise<void> {}
 
+  async updateCollectionStrict(collection: string): Promise<void> {
+    this.strictCollectionUpdates.push(collection);
+  }
+
   updatesAllCollections(): boolean {
     return this.globalUpdate;
   }
 
-  async embed(): Promise<void> {}
+  async embed(): Promise<void> {
+    this.embeds += 1;
+  }
+
+  async embedStrict(): Promise<void> {
+    this.strictEmbeds += 1;
+  }
 
-  async embedCollection(): Promise<void> {}
+  async embedCollection(collection: string): Promise<void> {
+    this.collectionEmbeds.push(collection);
+  }
+
+  async embedCollectionStrict(collection: string): Promise<void> {
+    this.strictCollectionEmbeds.push(collection);
+  }
 
   async ensureCollection(
     _memoryDir?: string,
@@ -253,6 +279,108 @@ test("updateNamespaces still updates every namespace for scoped backends", async
   assert.equal(created.reduce((sum, backend) => sum + backend.updates, 0), 3);
 });
 
+test("updateNamespaces uses strict global update when requested", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = new FakeBackend(true);
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  const updated = await router.updateNamespaces(
+    ["main", "shared", "main", "project"],
+    undefined,
+    { strict: true },
+  );
+
+  assert.equal(updated, 1);
+  assert.equal(created.reduce((sum, backend) => sum + backend.strictUpdates, 0), 1);
+  assert.equal(created.reduce((sum, backend) => sum + backend.updates, 0), 0);
+});
+
+test("updateNamespaces uses strict collection updates for scoped backends when requested", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = new FakeBackend(false);
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  const updated = await router.updateNamespaces(
+    ["main", "shared", "main", "project"],
+    undefined,
+    { strict: true },
+  );
+
+  assert.equal(updated, 3);
+  assert.equal(created.reduce((sum, backend) => sum + backend.strictCollectionUpdates.length, 0), 3);
+  assert.equal(created.reduce((sum, backend) => sum + backend.updates, 0), 0);
+});
+
+test("embedNamespaces uses strict collection embeds when requested", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = new FakeBackend(false);
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  await router.embedNamespaces(["main", "shared", "main", "project"], { strict: true });
+
+  assert.equal(created.reduce((sum, backend) => sum + backend.strictCollectionEmbeds.length, 0), 3);
+  assert.equal(created.reduce((sum, backend) => sum + backend.collectionEmbeds.length, 0), 0);
+  assert.equal(created.reduce((sum, backend) => sum + backend.embeds, 0), 0);
+});
+
+test("embedNamespaces propagates strict embed failures", async () => {
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = new FakeBackend(false);
+      backend.embedCollectionStrict = async () => {
+        throw new Error("embed failed");
+      };
+      return backend;
+    },
+  );
+
+  await assert.rejects(
+    () => router.embedNamespaces(["main"], { strict: true }),
+    /embed failed/,
+  );
+});
+
+test("updateNamespacesDetailed reports only eligible namespaces", async () => {
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    (scopedConfig) => {
+      const backend = new FakeBackend(false, [], {
+        ensure: scopedConfig.memoryDir.endsWith("/missing") ? "missing" : "present",
+      });
+      return backend;
+    },
+  );
+
+  const result = await router.updateNamespacesDetailed(["main", "missing", "shared"]);
+
+  assert.equal(result.backendCount, 2);
+  assert.deepEqual(result.eligibleNamespaces.sort(), ["main", "shared"]);
+});
+
 test("searchAcrossNamespaces preserves same path results from distinct namespaces", async () => {
   const router = new NamespaceSearchRouter(
     config(),

package/src/namespaces/search.ts

@@ -44,6 +44,11 @@ type NamespaceBackendRecord = {
   filtersNestedNamespaces: boolean;
 };
 
+export interface NamespaceUpdateResult {
+  backendCount: number;
+  eligibleNamespaces: string[];
+}
+
 export type CollectionState = "present" | "missing" | "unknown" | "skipped";
 
 export interface NamespaceSearchHealth {
@@ -161,37 +166,51 @@ export class NamespaceSearchRouter {
   async updateNamespaces(
     namespaces: string[],
     execution?: SearchExecutionOptions,
+    options?: { strict?: boolean },
   ): Promise<number> {
+    return (await this.updateNamespacesDetailed(namespaces, execution, options)).backendCount;
+  }
+
+  async updateNamespacesDetailed(
+    namespaces: string[],
+    execution?: SearchExecutionOptions,
+    options?: { strict?: boolean },
+  ): Promise<NamespaceUpdateResult> {
     const unique = Array.from(new Set(namespaces.map((value) => value.trim()).filter(Boolean)));
     const eligible = (await Promise.all(
       unique.map(async (namespace) => {
         const record = await this.backendRecordFor(namespace);
         return record.available && record.collectionState !== "missing"
-          ? record
+          ? { namespace, record }
           : null;
       }),
-    )).filter((record): record is NamespaceBackendRecord => record !== null);
+    )).filter((entry): entry is { namespace: string; record: NamespaceBackendRecord } => entry !== null);
 
-    const globalRecord = eligible.find((record) => record.backend.updatesAllCollections?.() === true);
-    const scopedRecords = globalRecord
-      ? eligible.filter((record) => record.backend.updatesAllCollections?.() !== true)
+    const globalEntry = eligible.find(({ record }) => record.backend.updatesAllCollections?.() === true);
+    const scopedEntries = globalEntry
+      ? eligible.filter(({ record }) => record.backend.updatesAllCollections?.() !== true)
       : eligible;
 
     await Promise.all([
-      globalRecord ? globalRecord.backend.update(execution) : Promise.resolve(),
-      ...scopedRecords.map((record) => record.backend.update(execution)),
+      globalEntry
+        ? updateBackendRecord(globalEntry.record, execution, options)
+        : Promise.resolve(),
+      ...scopedEntries.map(({ record }) => updateBackendRecord(record, execution, options)),
     ]);
 
-    return (globalRecord ? 1 : 0) + scopedRecords.length;
+    return {
+      backendCount: (globalEntry ? 1 : 0) + scopedEntries.length,
+      eligibleNamespaces: eligible.map(({ namespace }) => namespace),
+    };
   }
 
-  async embedNamespaces(namespaces: string[]): Promise<void> {
+  async embedNamespaces(namespaces: string[], options?: { strict?: boolean }): Promise<void> {
     const unique = Array.from(new Set(namespaces.map((value) => value.trim()).filter(Boolean)));
     await Promise.all(
       unique.map(async (namespace) => {
         const record = await this.backendRecordFor(namespace);
         if (!record.available || record.collectionState === "missing") return;
-        await record.backend.embed();
+        await embedBackendRecord(record, options);
       }),
     );
   }
@@ -442,6 +461,48 @@ function backendSearchLimit(
   );
 }
 
+async function updateBackendRecord(
+  record: NamespaceBackendRecord,
+  execution?: SearchExecutionOptions,
+  options?: { strict?: boolean },
+): Promise<void> {
+  if (options?.strict === true) {
+    if (
+      record.backend.updatesAllCollections?.() === true &&
+      typeof record.backend.updateStrict === "function"
+    ) {
+      await record.backend.updateStrict(execution);
+      return;
+    }
+    if (typeof record.backend.updateCollectionStrict === "function") {
+      await record.backend.updateCollectionStrict(record.collection, execution);
+      return;
+    }
+  }
+  await record.backend.update(execution);
+}
+
+async function embedBackendRecord(
+  record: NamespaceBackendRecord,
+  options?: { strict?: boolean },
+): Promise<void> {
+  if (options?.strict === true) {
+    if (typeof record.backend.embedCollectionStrict === "function") {
+      await record.backend.embedCollectionStrict(record.collection);
+      return;
+    }
+    if (typeof record.backend.embedStrict === "function") {
+      await record.backend.embedStrict();
+      return;
+    }
+  }
+  if (typeof record.backend.embedCollection === "function") {
+    await record.backend.embedCollection(record.collection);
+    return;
+  }
+  await record.backend.embed();
+}
+
 function daemonModeForBackend(backend: SearchBackend): boolean | null {
   return "isDaemonMode" in backend && typeof backend.isDaemonMode === "function"
     ? backend.isDaemonMode() === true