@peerbit/document 12.3.4 → 12.3.5-000e3f1

package/dist/src/search.js

@@ -753,7 +753,24 @@ let DocumentIndex = (() => {
                     this.documentEvents.removeEventListener("change", this.handleDocumentChange);
                 }
                 this.clearAllResultQueues();
-                await this.index?.stop?.();
+                await this._resumableIterators.clearAll();
+                if (this.iteratorKeepAliveTimers) {
+                    for (const timer of this.iteratorKeepAliveTimers.values()) {
+                        clearTimeout(timer);
+                    }
+                    this.iteratorKeepAliveTimers.clear();
+                }
+                try {
+                    await this.index?.stop?.();
+                }
+                catch (error) {
+                    // Be defensive during teardown: stopping an already-stopped index shouldn't
+                    // prevent closing the program and releasing timers/iterators.
+                    if (error instanceof indexerTypes.NotStartedError) {
+                        return closed;
+                    }
+                    throw error;
+                }
             }
             return closed;
         }
@@ -762,13 +779,35 @@ let DocumentIndex = (() => {
             if (dropped) {
                 this.documentEvents.removeEventListener("change", this.handleDocumentChange);
                 this.clearAllResultQueues();
-                await this.index?.drop?.();
-                await this.index?.stop?.();
+                await this._resumableIterators.clearAll();
+                if (this.iteratorKeepAliveTimers) {
+                    for (const timer of this.iteratorKeepAliveTimers.values()) {
+                        clearTimeout(timer);
+                    }
+                    this.iteratorKeepAliveTimers.clear();
+                }
+                try {
+                    await this.index?.drop?.();
+                }
+                catch (error) {
+                    if (!(error instanceof indexerTypes.NotStartedError)) {
+                        throw error;
+                    }
+                }
+                try {
+                    await this.index?.stop?.();
+                }
+                catch (error) {
+                    if (!(error instanceof indexerTypes.NotStartedError)) {
+                        throw error;
+                    }
+                }
             }
             return dropped;
         }
         async get(key, options) {
             let deferred;
+            let baseRemote;
             // Normalize the id key early so listeners can use it
             let idKey = key instanceof indexerTypes.IdKey ? key : indexerTypes.toId(key);
             if (options?.waitFor) {
@@ -801,11 +840,12 @@ let DocumentIndex = (() => {
                 this.documentEvents.addEventListener("change", listener);
                 deferred.promise.then(cleanup);
                 // Prepare remote options without mutating caller options
-                const baseRemote = options?.remote === false
-                    ? undefined
-                    : typeof options?.remote === "object"
-                        ? { ...options.remote }
-                        : {};
+                baseRemote =
+                    options?.remote === false
+                        ? undefined
+                        : typeof options?.remote === "object"
+                            ? { ...options.remote }
+                            : {};
                 if (baseRemote) {
                     const waitPolicy = baseRemote.wait;
                     if (!waitPolicy ||
@@ -842,7 +882,10 @@ let DocumentIndex = (() => {
                     });
                 }
             }
-            const result = (await this.getDetailed(idKey, options))?.[0]?.results[0];
+            const initialOptions = baseRemote
+                ? { ...options, remote: baseRemote }
+                : options;
+            const result = (await this.getDetailed(idKey, initialOptions))?.[0]?.results[0];
             // if no results, and we have remote joining options, we wait for the timout and if there are joining peers we re-query
             if (!result) {
                 return deferred?.promise;
@@ -1142,6 +1185,8 @@ let DocumentIndex = (() => {
                     fromQuery: (fromQuery || query),
                     resolveResults: resolveFlag,
                 };
+                // Don't keep Node alive just to GC old remote iterator state.
+                prevQueued.timeout.unref?.();
                 if (fromQuery instanceof types.IterationRequest &&
                     fromQuery.pushUpdates) {
                     prevQueued.pushMode = fromQuery.pushUpdates;
@@ -1228,6 +1273,8 @@ let DocumentIndex = (() => {
                 }
                 this._resumableIterators.close({ idString });
             }, delay);
+            // This is a best-effort cleanup timer; it should not keep Node alive.
+            timer.unref?.();
             timers.set(idString, timer);
         }
         cancelIteratorKeepAlive(idString) {
@@ -1409,12 +1456,7 @@ let DocumentIndex = (() => {
             const local = typeof options?.local === "boolean" ? options?.local : true;
             let remote = undefined;
             if (typeof options?.remote === "boolean") {
-                if (options?.remote) {
-                    remote = {};
-                }
-                else {
-                    remote = undefined;
-                }
+                remote = options.remote ? {} : undefined;
             }
             else {
                 remote = options?.remote || {};
@@ -1425,6 +1467,13 @@ let DocumentIndex = (() => {
                 // this will lead to bad UX as you usually want to list/expore whats going on before doing any replication work
                 remote.priority = 2;
             }
+            if (remote && remote.timeout == null && options?.remote) {
+                const waitPolicy = typeof options.remote === "object" ? options.remote.wait : undefined;
+                const waitTimeout = typeof waitPolicy === "object" ? waitPolicy.timeout : undefined;
+                if (waitTimeout != null) {
+                    remote.timeout = waitTimeout;
+                }
+            }
             if (!local && !remote) {
                 throw new Error("Expecting either 'options.remote' or 'options.local' to be true");
             }
@@ -1443,14 +1492,69 @@ let DocumentIndex = (() => {
                     // don't wait for responses
                     throw new Error("Unexpected");
                 }
-                const replicatorGroups = options?.remote?.from
+                const coverProps = remote.domain ?? { args: undefined };
+                const isDefaultDomainArgs = !("range" in coverProps) &&
+                    (!("args" in coverProps) || coverProps.args == null);
+                let replicatorGroups = options?.remote?.from
                     ? options?.remote?.from
-                    : await this._log.getCover(remote.domain ?? { args: undefined }, {
+                    : await this._log.getCover(coverProps, {
                         roleAge: remote.minAge,
                         eager: remote.reach?.eager,
                         reachableOnly: !!remote.wait, // when we want to merge joining we can ignore pending to be online peers and instead consider them once they become online
                         signal: options?.signal,
                     });
+                // Cold start: cover can be temporarily empty/self-only while replication metadata
+                // converges. For remote search, it's sometimes better to at least try currently
+                // connected peers, but only if we have evidence that a remote replicator exists.
+                if (!options?.remote?.from && isDefaultDomainArgs) {
+                    const selfHash = this.node.identity.publicKey.hashcode();
+                    const remoteCount = replicatorGroups.filter((h) => h !== selfHash).length;
+                    if (remoteCount === 0) {
+                        const waitEnabled = Boolean(remote.wait);
+                        const coverIsSelfOnly = replicatorGroups.length === 1 && replicatorGroups[0] === selfHash;
+                        // If the cover is explicitly empty (no shards), don't override it unless
+                        // the caller requested waiting for joins (e.g. get(waitFor)).
+                        if (!waitEnabled && !coverIsSelfOnly) {
+                            // no-op
+                        }
+                        else {
+                            let hasKnownRemoteReplicator = false;
+                            if (!waitEnabled) {
+                                try {
+                                    const replicators = await this._log.getReplicators();
+                                    for (const hash of replicators.keys()) {
+                                        if (hash !== selfHash) {
+                                            hasKnownRemoteReplicator = true;
+                                            break;
+                                        }
+                                    }
+                                }
+                                catch {
+                                    // Best-effort only.
+                                }
+                            }
+                            if (waitEnabled || hasKnownRemoteReplicator) {
+                                const peerMap = this.node.services
+                                    .pubsub?.peers;
+                                if (peerMap?.keys) {
+                                    const extra = [];
+                                    for (const hash of peerMap.keys()) {
+                                        if (!hash || hash === selfHash)
+                                            continue;
+                                        extra.push(hash);
+                                        if (extra.length >= 8)
+                                            break;
+                                    }
+                                    if (extra.length > 0) {
+                                        replicatorGroups = [
+                                            ...new Set([...replicatorGroups, ...extra]),
+                                        ];
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
                 if (replicatorGroups) {
                     const responseHandler = async (results) => {
                         const resultInitialized = await introduceEntries(queryRequest, results, this.documentType, this.indexedType, this._sync, options);
@@ -1529,6 +1633,9 @@ let DocumentIndex = (() => {
                     catch (error) {
                         if (error instanceof MissingResponsesError) {
                             warn("Did not reciveve responses from all shard");
+                            if (options?.onMissingResponses) {
+                                await options.onMissingResponses(error);
+                            }
                             if (remote?.throwOnMissing) {
                                 throw error;
                             }
@@ -1575,9 +1682,8 @@ let DocumentIndex = (() => {
             // Set fetch to search size, or max value (default to max u32 (4294967295))
             const coercedRequest = coerceQuery(queryRequest, options, this.compatibility);
             coercedRequest.fetch = coercedRequest.fetch ?? 0xffffffff;
-            // So that the iterator is pre-fetching the right amount of entries
+            // Use an iterator so large results respect message size limits.
             const iterator = this.iterate(coercedRequest, options);
-            // So that this call will not do any remote requests
             const allResults = [];
             while (iterator.done() !== true &&
                 coercedRequest.fetch > allResults.length) {
@@ -1838,36 +1944,42 @@ let DocumentIndex = (() => {
             let discoveredTargetHashes;
             if (typeof options?.remote === "object") {
                 let waitForTime = undefined;
+                const waitPolicy = typeof options.remote.wait === "object"
+                    ? options.remote.wait
+                    : undefined;
+                const waitBehavior = waitPolicy?.behavior ?? "keep-open";
                 if (options.remote.wait) {
-                    let t0 = +new Date();
                     waitForTime =
                         typeof options.remote.wait === "boolean"
                             ? DEFAULT_TIMEOUT
                             : (options.remote.wait.timeout ?? DEFAULT_TIMEOUT);
-                    let setDoneIfTimeout = false;
-                    maybeSetDone = () => {
-                        if (t0 + waitForTime < +new Date()) {
-                            cleanup();
-                            done = true;
-                        }
-                        else {
-                            setDoneIfTimeout = true;
-                        }
-                    };
-                    unsetDone = () => {
-                        setDoneIfTimeout = false;
-                        done = false;
-                    };
-                    let timeout = setTimeout(() => {
-                        if (setDoneIfTimeout) {
-                            cleanup();
-                            done = true;
-                        }
-                    }, waitForTime);
-                    cleanup = () => {
-                        this.clearResultsQueue(queryRequestCoerced);
-                        clearTimeout(timeout);
-                    };
+                    if (waitBehavior === "keep-open") {
+                        let t0 = +new Date();
+                        let setDoneIfTimeout = false;
+                        maybeSetDone = () => {
+                            if (t0 + waitForTime < +new Date()) {
+                                cleanup();
+                                done = true;
+                            }
+                            else {
+                                setDoneIfTimeout = true;
+                            }
+                        };
+                        unsetDone = () => {
+                            setDoneIfTimeout = false;
+                            done = false;
+                        };
+                        let timeout = setTimeout(() => {
+                            if (setDoneIfTimeout) {
+                                cleanup();
+                                done = true;
+                            }
+                        }, waitForTime);
+                        cleanup = () => {
+                            this.clearResultsQueue(queryRequestCoerced);
+                            clearTimeout(timeout);
+                        };
+                    }
                 }
                 if (options.remote.reach?.discover) {
                     const discoverTimeout = waitForTime ??
@@ -1891,9 +2003,6 @@ let DocumentIndex = (() => {
                     warmupPromise = prior.then(() => discoverPromise);
                     options.remote.reach.eager = true; // include the results from the discovered peer even if it is not mature
                 }
-                const waitPolicy = typeof options.remote.wait === "object"
-                    ? options.remote.wait
-                    : undefined;
                 if (waitPolicy?.behavior === "block" &&
                     (waitPolicy.until ?? "any") === "any") {
                     const blockPromise = this.waitForCoverReady({
@@ -1912,6 +2021,7 @@ let DocumentIndex = (() => {
             const fetchFirst = async (n, fetchOptions) => {
                 await warmupPromise;
                 let hasMore = false;
+                let missingResponses = false;
                 const discoverTargets = typeof options?.remote === "object"
                     ? options.remote.reach?.discover
                     : undefined;
@@ -2012,7 +2122,31 @@ let DocumentIndex = (() => {
                             throw new Error("Unsupported result type: " + response?.constructor?.name);
                         }
                     },
+                    onMissingResponses: (error) => {
+                        missingResponses = true;
+                        const missingGroups = error.missingGroups;
+                        if (!missingGroups?.length) {
+                            return;
+                        }
+                        const selfHash = this.node.identity.publicKey.hashcode();
+                        for (const group of missingGroups) {
+                            const target = group.find((hash) => {
+                                if (!hash || hash === selfHash)
+                                    return false;
+                                const attempts = missingResponseRetryAttempts.get(hash) ?? 0;
+                                return attempts < maxMissingResponseRetryAttempts;
+                            });
+                            if (!target)
+                                continue;
+                            pendingMissingResponseRetryPeers.add(target);
+                            missingResponseRetryAttempts.set(target, (missingResponseRetryAttempts.get(target) ?? 0) + 1);
+                        }
+                    },
                 }, fetchOptions?.fetchedFirstForRemote);
+                if (missingResponses) {
+                    hasMore = true;
+                    unsetDone();
+                }
                 if (!hasMore) {
                     maybeSetDone();
                 }
@@ -2032,6 +2166,16 @@ let DocumentIndex = (() => {
                     fetchPromise = fetchFirst(n);
                     return fetchPromise;
                 }
+                if (pendingMissingResponseRetryPeers.size > 0) {
+                    const retryTargets = [...pendingMissingResponseRetryPeers];
+                    pendingMissingResponseRetryPeers.clear();
+                    fetchPromise = fetchFirst(n, {
+                        from: retryTargets,
+                        // retries for missing groups should not be suppressed by first-fetch dedupe
+                        fetchedFirstForRemote: undefined,
+                    });
+                    return fetchPromise;
+                }
                 const promises = [];
                 let resultsLeft = 0;
                 for (const [peer, buffer] of peerBufferMap) {
@@ -2300,25 +2444,19 @@ let DocumentIndex = (() => {
             };
             let close = async () => {
                 cleanupAndDone();
-                // send close to remote
+                // send close to remote (only peers that actually served results / had an active buffer)
                 const closeRequest = new types.CloseIteratorRequest({
                     id: queryRequestCoerced.id,
                 });
-                const promises = [];
-                for (const [peer, buffer] of peerBufferMap) {
-                    if (buffer.kept === 0) {
-                        peerBufferMap.delete(peer);
-                        continue;
-                    }
-                    if (peer !== this.node.identity.publicKey.hashcode()) {
-                        // Close remote
-                        promises.push(this._query.send(closeRequest, {
-                            ...options,
-                            mode: new SilentDelivery({ to: [peer], redundancy: 1 }),
-                        }));
-                    }
-                }
-                await Promise.all(promises);
+                const selfHash = this.node.identity.publicKey.hashcode();
+                const remotePeers = [...peerBufferMap.entries()]
+                    .filter(([peer, buffer]) => peer !== selfHash && buffer.kept > 0)
+                    .map(([peer]) => peer);
+                peerBufferMap.clear();
+                await Promise.allSettled(remotePeers.map((peer) => this._query.send(closeRequest, {
+                    ...options,
+                    mode: new SilentDelivery({ to: [peer], redundancy: 1 }),
+                })));
             };
             options?.signal && options.signal.addEventListener("abort", close);
             let doneFn = () => {
@@ -2326,6 +2464,9 @@ let DocumentIndex = (() => {
             };
             let joinListener;
             let fetchedFirstForRemote = undefined;
+            const pendingMissingResponseRetryPeers = new Set();
+            const missingResponseRetryAttempts = new Map();
+            const maxMissingResponseRetryAttempts = 2;
             let updateDeferred;
             const onLateResultsQueue = options?.outOfOrder?.mode === "queue" &&
                 typeof options?.outOfOrder?.handle === "function"
@@ -2746,10 +2887,17 @@ let DocumentIndex = (() => {
                     return cleanupDefaultUpdates();
                 };
             }
-            if (typeof options?.remote === "object" && options?.remote.wait) {
+            const remoteConfig = options && typeof options.remote === "object" ? options.remote : undefined;
+            const remoteWaitPolicy = remoteConfig && typeof remoteConfig.wait === "object"
+                ? remoteConfig.wait
+                : undefined;
+            const remoteWaitBehavior = remoteWaitPolicy?.behavior ?? "keep-open";
+            const keepRemoteWaitOpen = !!remoteConfig?.wait &&
+                remoteWaitBehavior === "keep-open";
+            if (keepRemoteWaitOpen) {
                 // was used to account for missed results when a peer joins; omitted in this minimal handler
                 updateDeferred = pDefer();
-                const waitForTime = typeof options.remote.wait === "object" && options.remote.wait.timeout;
+                const waitForTime = remoteWaitPolicy?.timeout;
                 const prevMaybeSetDone = maybeSetDone;
                 maybeSetDone = () => {
                     prevMaybeSetDone();
@@ -2764,7 +2912,7 @@ let DocumentIndex = (() => {
                 fetchedFirstForRemote = new Set();
                 joinListener = this.createReplicatorJoinListener({
                     signal: ensureController().signal,
-                    eager: options.remote.reach?.eager,
+                    eager: remoteConfig?.reach?.eager,
                     onPeer: async (pk) => {
                         if (done)
                             return;
@@ -2823,7 +2971,7 @@ let DocumentIndex = (() => {
                     }
                 };
             }
-            const remoteWaitActive = typeof options?.remote === "object" && !!options.remote.wait;
+            const remoteWaitActive = keepRemoteWaitOpen;
             const waitForUpdateAndResetDeferred = async () => {
                 if (remoteWaitActive) {
                     // wait until: join fetch adds results, cleanup runs, or the join-wait times out