@docstack/react 0.0.9 → 0.1.1

package/lib/components/StackProvider/index.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
 import { DocStack } from '@docstack/client';
-import { ClientCredentials, StackConfig } from '@docstack/shared';
+import { ClientCredentials, StackConfig } from '@docstack/client';
 /**
  * Context object for the DocStack instance.
  * It provides the current DocStack instance or null if not initialized.
@@ -39,23 +39,40 @@ export interface DocStackProviderProps {
     config: StackConfig[];
     /** Credentials for the stack(s). Can be a single object or an array matching the config. */
     credentials?: ClientCredentials | ClientCredentials[];
+    /**
+     * Delete the underlying database when a stack drops out of `config`. Defaults to
+     * `false`: a workspace that disappears from the configuration is closed, not erased.
+     */
+    destroyRemovedStacks?: boolean;
     /** Child components. */
     children?: ReactNode;
 }
 /**
  * A provider component that initializes the DocStack client and makes it available
  * to child components via the {@link useDocStack} hook.
- * It handles the asynchronous initialization of the stack(s).
+ *
+ * The `config` prop is reconciled rather than read once: a stack that appears in it is
+ * opened, a stack that disappears is closed, and the stacks either side of the change
+ * are left running. An application whose set of databases grows at runtime - one per
+ * workspace, say - therefore does not have to reload to pick up a new one, which
+ * matters once each stack also carries a live replication that a reload would drop.
  *
  * @example
  * ```tsx
  * import { StackProvider } from '@docstack/react';
  *
- * const App = () => (
- *     <StackProvider config={[{ name: 'my-db' }]}>
- *         <MyApp />
- *     </StackProvider>
- * );
+ * const App = () => {
+ *     const workspaces = useWorkspaces();
+ *     const config = useMemo(
+ *         () => [{ name: 'app' }, ...workspaces.map(w => ({ name: `ws-${w.slug}` }))],
+ *         [workspaces]
+ *     );
+ *     return (
+ *         <StackProvider config={config}>
+ *             <MyApp />
+ *         </StackProvider>
+ *     );
+ * };
  * ```
  */
 declare const StackProvider: (props: DocStackProviderProps) => import("react/jsx-runtime").JSX.Element;

package/lib/components/StackProvider/index.js

@@ -1,5 +1,14 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useRef, useCallback, useEffect, useState } from 'react';
+import { createContext, useContext, useRef, useCallback, useEffect, useMemo, useReducer, useState } from 'react';
 import { DocStack } from '@docstack/client'; // Import your DocStack class
 // You can give it a default value, e.g., null, which can be checked later.
 /**
@@ -26,52 +35,121 @@ export const DocStackContext = createContext(null);
 export const useDocStack = () => {
     return useContext(DocStackContext);
 };
+/**
+ * The name a configuration entry will end up carrying as a stack.
+ *
+ * Mirrors `DocStack.resolveStackConfig`: a string configuration *is* the name, an
+ * object's `name` wins, and a connection-only entry is identified by its connection.
+ *
+ * @param config - One stack configuration.
+ * @returns The identifier to reconcile on.
+ */
+const stackKey = (config) => {
+    if (typeof config === 'string')
+        return config;
+    return config.name || config.connection || '';
+};
+/**
+ * Merges the `credentials` prop into the configurations it applies to.
+ *
+ * @param config - The configurations as given.
+ * @param credentials - One credential for every stack, or one per configuration entry.
+ * @returns Configurations with credentials folded in.
+ */
+const mergeCredentials = (config, credentials) => config.map((cfg, idx) => {
+    const cred = Array.isArray(credentials) ? credentials[idx] : credentials;
+    if (typeof cfg === 'string') {
+        return cred ? { connection: `db-${cfg}`, name: cfg, credentials: cred } : cfg;
+    }
+    return cred ? Object.assign(Object.assign({}, cfg), { credentials: cred }) : cfg;
+});
 /**
  * A provider component that initializes the DocStack client and makes it available
  * to child components via the {@link useDocStack} hook.
- * It handles the asynchronous initialization of the stack(s).
+ *
+ * The `config` prop is reconciled rather than read once: a stack that appears in it is
+ * opened, a stack that disappears is closed, and the stacks either side of the change
+ * are left running. An application whose set of databases grows at runtime - one per
+ * workspace, say - therefore does not have to reload to pick up a new one, which
+ * matters once each stack also carries a live replication that a reload would drop.
  *
  * @example
  * ```tsx
  * import { StackProvider } from '@docstack/react';
  *
- * const App = () => (
- *     <StackProvider config={[{ name: 'my-db' }]}>
- *         <MyApp />
- *     </StackProvider>
- * );
+ * const App = () => {
+ *     const workspaces = useWorkspaces();
+ *     const config = useMemo(
+ *         () => [{ name: 'app' }, ...workspaces.map(w => ({ name: `ws-${w.slug}` }))],
+ *         [workspaces]
+ *     );
+ *     return (
+ *         <StackProvider config={config}>
+ *             <MyApp />
+ *         </StackProvider>
+ *     );
+ * };
  * ```
  */
 const StackProvider = (props) => {
-    const { config, children, credentials } = props;
+    const { config, children, credentials, destroyRemovedStacks } = props;
     // Use a ref to store the DocStack instance
     const docStackRef = useRef(null);
     const [docStack, setDocStack] = useState(null);
+    // The DocStack instance is stable across reconciliations, so adding or removing a
+    // stack changes nothing React can see by itself.
+    const [, signalStacksChanged] = useReducer((count) => count + 1, 0);
+    // Reconciliations are serialized: opening a database is asynchronous and two
+    // overlapping passes would race to add the same stack twice.
+    const reconciling = useRef(Promise.resolve());
+    const mergedConfig = useMemo(() => mergeCredentials(config, credentials), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(config), JSON.stringify(credentials)]);
     const setsDocStackWhenReady = useCallback(() => {
         setDocStack(docStackRef.current);
     }, []);
     useEffect(() => {
-        if (docStackRef.current === null && config.length) {
-            console.log("DocStack provider - init instance", { config });
-            const mergedConfig = config.map((cfg, idx) => {
-                const cred = Array.isArray(credentials) ? credentials[idx] : credentials;
-                if (typeof cfg === "string") {
-                    return cred ? { connection: cfg, credentials: cred } : cfg;
-                }
-                return cred ? Object.assign(Object.assign({}, cfg), { credentials: cred }) : cfg;
-            });
+        if (!mergedConfig.length)
+            return;
+        if (docStackRef.current === null) {
+            console.log("DocStack provider - init instance", { config: mergedConfig });
             const instance = new DocStack(...mergedConfig);
             docStackRef.current = instance;
-            docStackRef.current.addEventListener("ready", setsDocStackWhenReady);
+            instance.addEventListener("ready", setsDocStackWhenReady);
+            instance.addEventListener("stack-added", signalStacksChanged);
+            instance.addEventListener("stack-removed", signalStacksChanged);
+            return;
         }
-        // Optional: Cleanup function to remove listeners
-        return () => {
-            if (docStackRef.current) {
-                // docStackRef.current.removeEventListener("ready", setsDocStackWhenReady);
-                // docStackRef.current.getStore().removeAllListeners();
+        const instance = docStackRef.current;
+        let cancelled = false;
+        const reconcile = () => __awaiter(void 0, void 0, void 0, function* () {
+            if (cancelled)
+                return;
+            const wanted = new Map(mergedConfig.map(cfg => [stackKey(cfg), cfg]));
+            for (const stack of [...instance.getStacks()]) {
+                if (cancelled)
+                    return;
+                if (!wanted.has(stack.name)) {
+                    console.log("DocStack provider - closing stack dropped from config", { name: stack.name });
+                    yield instance.removeStack(stack.name, { destroy: destroyRemovedStacks });
+                }
+            }
+            for (const [name, cfg] of wanted) {
+                if (cancelled)
+                    return;
+                if (!instance.getStack(name)) {
+                    console.log("DocStack provider - opening stack added to config", { name });
+                    yield instance.addStack(cfg);
+                }
             }
+        });
+        reconciling.current = reconciling.current.then(reconcile).catch(error => {
+            console.error("DocStack provider - failed to reconcile stacks", error);
+        });
+        return () => {
+            cancelled = true;
         };
-    }, [config, credentials, setsDocStackWhenReady]);
+    }, [mergedConfig, destroyRemovedStacks, setsDocStackWhenReady]);
     return (_jsx(DocStackContext.Provider, { value: docStack, children: children }));
 };
 export default StackProvider;

package/lib/hooks/class.d.ts

@@ -1,5 +1,5 @@
 import { Class } from "@docstack/client";
-import { Document } from "@docstack/shared";
+import { Document } from "@docstack/client";
 /**
  * Hook to create a new Class in a specific stack.
  *

package/lib/hooks/class.js

@@ -39,7 +39,9 @@ export const useClassCreate = (stack) => {
             if (!docStack) {
                 // Handle the case where the provider is not yet initialized or missing
                 // You could throw an error or return an empty state.
-                console.error('useClassCreate must be used within a DocStackProvider.');
+                // Null until the provider's `ready` event; that is startup,
+                // not a missing provider. See ADR-0022.
+                console.warn('useClassCreate - stack not ready yet; the call was ignored.');
                 // setLoading(false);
                 return Promise.resolve(null);
             }
@@ -94,7 +96,10 @@ export const useClassList = (stack, selector) => {
     useEffect(() => {
         // Only run if the docStack is available and a className is provided
         if (!docStack) {
-            setLoading(false);
+            // Null until the provider's `ready` event: startup, not a missing
+            // provider. Reporting "loaded" here is indistinguishable from a genuinely
+            // empty result. See ADR-0022.
+            setLoading(true);
             return;
         }
         const fetchClass = () => __awaiter(void 0, void 0, void 0, function* () {
@@ -123,6 +128,8 @@ export const useClassList = (stack, selector) => {
         if (!originClass) {
             return;
         }
+        let cancelled = false;
+        let attached = null;
         const runQueryAndListen = () => __awaiter(void 0, void 0, void 0, function* () {
             setLoading(true);
             try {
@@ -133,15 +140,26 @@ export const useClassList = (stack, selector) => {
                     const classInstance = yield Class.buildFromModel(stackInstance, cls);
                     initialClassList.push(classInstance);
                 }
+                if (cancelled) {
+                    // The effect was torn down mid-query; these were built anyway, and
+                    // each one holds a live subscription until it is closed.
+                    for (const classInstance of initialClassList)
+                        classInstance.close();
+                    return;
+                }
                 classListRef.current = initialClassList;
                 setClassList(classListRef.current);
             }
             catch (err) {
-                setError(err);
+                if (!cancelled)
+                    setError(err);
             }
             finally {
-                setLoading(false);
+                if (!cancelled)
+                    setLoading(false);
             }
+            if (cancelled)
+                return;
             const changeListener = (change) => {
                 const doc = change.detail.doc;
                 console.log("useClassDocs - detail", { detail: change.detail });
@@ -174,12 +192,24 @@ export const useClassList = (stack, selector) => {
                 }
                 setClassList([...classListRef.current]);
             };
-            originClass.addEventListener('doc', changeListener);
-            return () => {
-                originClass.removeEventListener('doc', changeListener);
-            };
+            attached = changeListener;
+            originClass.addEventListener('doc', attached);
         });
         runQueryAndListen();
+        // The cleanup used to be returned from `runQueryAndListen`, where React never saw
+        // it: the listener stayed attached and the built classes stayed subscribed for
+        // every render that changed the selector.
+        return () => {
+            var _a;
+            cancelled = true;
+            if (attached)
+                originClass.removeEventListener('doc', attached);
+            // Guarded: the change handler above pushes the raw document for a class it
+            // has not seen before, so the list is not uniformly Class instances.
+            for (const classInstance of classListRef.current)
+                (_a = classInstance === null || classInstance === void 0 ? void 0 : classInstance.close) === null || _a === void 0 ? void 0 : _a.call(classInstance);
+            classListRef.current = [];
+        };
     }, [originClass, JSON.stringify(selector)]); // Dependency on classObj and query
     return { classList, loading, error };
 };
@@ -212,8 +242,14 @@ export const useClass = (stack, className) => {
         if (!docStack) {
             // Handle the case where the provider is not yet initialized or missing
             // You could throw an error or return an empty state.
-            console.error('useClass must be used within a DocStackProvider.');
-            setLoading(false);
+            // The provider publishes `null` into the context until its `ready`
+            // event fires, so this is the normal startup window, not a missing
+            // provider. Reporting it as one sends the reader hunting for a bug
+            // that is not there - and `setLoading(false)` was worse than the
+            // message: it tells a consumer "loaded, and empty" during startup,
+            // which is indistinguishable from a genuinely empty result. See
+            // ADR-0022.
+            setLoading(true);
             return;
         }
         const fetchClass = () => __awaiter(void 0, void 0, void 0, function* () {
@@ -280,7 +316,16 @@ export const useClassDocs = (stack, className, query = {}) => {
     const [error, setError] = useState(null);
     useEffect(() => {
         // Only run if the docStack is available and a className is provided
-        if (!docStack || !className) {
+        if (!docStack) {
+            // Null until the provider's `ready` event: startup, not a missing
+            // provider. Reporting "loaded" here is indistinguishable from a genuinely
+            // empty result. See ADR-0022.
+            setLoading(true);
+            return;
+        }
+        if (!className) {
+            // A genuinely absent className is "nothing to load", which is a settled state -
+            // unlike the pre-ready window above.
             setLoading(false);
             return;
         }
@@ -310,20 +355,28 @@ export const useClassDocs = (stack, className, query = {}) => {
         if (!classObj) {
             return;
         }
+        let cancelled = false;
+        let attached = null;
         const runQueryAndListen = () => __awaiter(void 0, void 0, void 0, function* () {
             setLoading(true);
             try {
-                debugger;
+                // debugger;
                 const initialDocs = yield classObj.getCards(query);
+                if (cancelled)
+                    return;
                 docsRef.current = initialDocs;
                 setDocs(docsRef.current);
             }
             catch (err) {
-                setError(err);
+                if (!cancelled)
+                    setError(err);
             }
             finally {
-                setLoading(false);
+                if (!cancelled)
+                    setLoading(false);
             }
+            if (cancelled)
+                return;
             const changeListener = (change) => {
                 const doc = change.detail.doc;
                 console.log("useClassDocs - detail", { detail: change.detail });
@@ -359,12 +412,17 @@ export const useClassDocs = (stack, className, query = {}) => {
                 }
                 setDocs([...docsRef.current]);
             };
-            classObj.addEventListener('doc', changeListener);
-            return () => {
-                classObj.removeEventListener('doc', changeListener);
-            };
+            attached = changeListener;
+            classObj.addEventListener('doc', attached);
         });
         runQueryAndListen();
+        // The cleanup used to be returned from `runQueryAndListen`, so React never
+        // received it and each query change left another listener on the class.
+        return () => {
+            cancelled = true;
+            if (attached)
+                classObj.removeEventListener('doc', attached);
+        };
     }, [classObj, JSON.stringify(query)]); // Dependency on classObj and query
     return { docs, loading, error };
 };

package/lib/hooks/domain.d.ts

@@ -1,5 +1,4 @@
-import { Class } from "@docstack/client";
-import { Domain, RelationDocument } from "@docstack/shared";
+import { Class, Domain, RelationDocument } from "@docstack/client";
 /**
  * Hook to create a new Domain in a specific stack.
  *

package/lib/hooks/domain.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { useContext, useCallback, useEffect, useRef, useState } from "react";
 import { DocStackContext } from "../components/StackProvider/index.js";
-import { Domain } from "@docstack/shared";
+import { Domain } from "@docstack/client";
 /**
  * Hook to create a new Domain in a specific stack.
  *
@@ -43,7 +43,9 @@ export const useDomainCreate = (stack) => {
             if (!docStack) {
                 // Handle the case where the provider is not yet initialized or missing
                 // You could throw an error or return an empty state.
-                console.error('useDomainCreate must be used within a DocStackProvider.');
+                // Null until the provider's `ready` event; that is startup,
+                // not a missing provider. See ADR-0022.
+                console.warn('useDomainCreate - stack not ready yet; the call was ignored.');
                 // setLoading(false);
                 return Promise.resolve(null);
             }
@@ -97,7 +99,10 @@ export const useDomainList = (stack, selector) => {
     useEffect(() => {
         // Only run if the docStack is available and a className is provided
         if (!docStack) {
-            setLoading(false);
+            // Null until the provider's `ready` event: startup, not a missing
+            // provider. Reporting "loaded" here is indistinguishable from a genuinely
+            // empty result. See ADR-0022.
+            setLoading(true);
             return;
         }
         const fetchClass = () => __awaiter(void 0, void 0, void 0, function* () {
@@ -126,21 +131,34 @@ export const useDomainList = (stack, selector) => {
         if (!originClass) {
             return;
         }
+        let cancelled = false;
+        let attached = null;
         const runQueryAndListen = () => __awaiter(void 0, void 0, void 0, function* () {
             setLoading(true);
             try {
                 const stackInstance = docStack.getStack(stack);
                 const initialDomainModelList = yield originClass.getCards(selector);
                 const initDomainList = yield Promise.all(initialDomainModelList.map((dm) => __awaiter(void 0, void 0, void 0, function* () { return yield Domain.buildFromModel(stackInstance, dm); })));
+                if (cancelled) {
+                    // Torn down mid-query; these were built anyway and each holds a live
+                    // subscription until it is closed.
+                    for (const domain of initDomainList)
+                        domain.close();
+                    return;
+                }
                 domainListRef.current = initDomainList;
                 setDomainList(domainListRef.current);
             }
             catch (err) {
-                setError(err);
+                if (!cancelled)
+                    setError(err);
             }
             finally {
-                setLoading(false);
+                if (!cancelled)
+                    setLoading(false);
             }
+            if (cancelled)
+                return;
             const changeListener = (change) => {
                 const doc = change.detail.doc;
                 if (!doc.active) {
@@ -171,12 +189,23 @@ export const useDomainList = (stack, selector) => {
                 }
                 setDomainList([...domainListRef.current]);
             };
-            originClass.addEventListener('doc', changeListener);
-            return () => {
-                originClass.removeEventListener('doc', changeListener);
-            };
+            attached = changeListener;
+            originClass.addEventListener('doc', attached);
         });
         runQueryAndListen();
+        // The cleanup used to be returned from `runQueryAndListen`, where React never saw
+        // it: the listener stayed attached and the built domains stayed subscribed.
+        return () => {
+            var _a;
+            cancelled = true;
+            if (attached)
+                originClass.removeEventListener('doc', attached);
+            // Guarded: the change handler above pushes the raw document for a domain it
+            // has not seen before, so the list is not uniformly Domain instances.
+            for (const domain of domainListRef.current)
+                (_a = domain === null || domain === void 0 ? void 0 : domain.close) === null || _a === void 0 ? void 0 : _a.call(domain);
+            domainListRef.current = [];
+        };
     }, [originClass, JSON.stringify(selector)]); // Dependency on classObj and query
     return { domainList, loading, error };
 };
@@ -209,8 +238,14 @@ export const useDomain = (stack, domainName) => {
         if (!docStack) {
             // Handle the case where the provider is not yet initialized or missing
             // You could throw an error or return an empty state.
-            console.error('useDomain must be used within a DocStackProvider.');
-            setLoading(false);
+            // The provider publishes `null` into the context until its `ready`
+            // event fires, so this is the normal startup window, not a missing
+            // provider. Reporting it as one sends the reader hunting for a bug
+            // that is not there - and `setLoading(false)` was worse than the
+            // message: it tells a consumer "loaded, and empty" during startup,
+            // which is indistinguishable from a genuinely empty result. See
+            // ADR-0022.
+            setLoading(true);
             return;
         }
         const fetchClass = () => __awaiter(void 0, void 0, void 0, function* () {
@@ -279,7 +314,16 @@ export const useDomainRelations = (stack, domainName, query = {}) => {
     const [error, setError] = useState(null);
     useEffect(() => {
         // Only run if the docStack is available and a className is provided
-        if (!docStack || !domainName) {
+        if (!docStack) {
+            // Null until the provider's `ready` event: startup, not a missing
+            // provider. Reporting "loaded" here is indistinguishable from a genuinely
+            // empty result. See ADR-0022.
+            setLoading(true);
+            return;
+        }
+        if (!domainName) {
+            // A genuinely absent domainName is "nothing to load", which is a settled state -
+            // unlike the pre-ready window above.
             setLoading(false);
             return;
         }
@@ -309,19 +353,27 @@ export const useDomainRelations = (stack, domainName, query = {}) => {
         if (!domain) {
             return;
         }
+        let cancelled = false;
+        let attached = null;
         const runQueryAndListen = () => __awaiter(void 0, void 0, void 0, function* () {
             setLoading(true);
             try {
                 const initialDocs = yield domain.getRelations(query);
+                if (cancelled)
+                    return;
                 docsRef.current = initialDocs;
                 setDocs(docsRef.current);
             }
             catch (err) {
-                setError(err);
+                if (!cancelled)
+                    setError(err);
             }
             finally {
-                setLoading(false);
+                if (!cancelled)
+                    setLoading(false);
             }
+            if (cancelled)
+                return;
             const changeListener = (change) => {
                 const doc = change.detail.doc;
                 if (!doc.active) {
@@ -355,12 +407,17 @@ export const useDomainRelations = (stack, domainName, query = {}) => {
                 }
                 setDocs([...docsRef.current]);
             };
-            domain.addEventListener('doc', changeListener);
-            return () => {
-                domain.removeEventListener('doc', changeListener);
-            };
+            attached = changeListener;
+            domain.addEventListener('doc', attached);
         });
         runQueryAndListen();
+        // The cleanup used to be returned from `runQueryAndListen`, so React never
+        // received it and each query change left another listener on the domain.
+        return () => {
+            cancelled = true;
+            if (attached)
+                domain.removeEventListener('doc', attached);
+        };
     }, [domain, JSON.stringify(query)]); // Dependency on classObj and query
     return { docs, loading, error };
 };

package/lib/hooks/index.d.ts

@@ -1,11 +1,17 @@
-import { Document, SelectAST, UnionAST } from '@docstack/shared';
+import { Document, SelectAST, UnionAST } from '@docstack/client';
 /**
  * Hook to execute a SQL query against a specific stack.
  *
+ * Live by default: the query re-runs when a document changes in a class it actually
+ * reads, derived from the `ast` the query itself returns. It used to run once and never
+ * again, which was invisible beside `useClassDocs` in the same import - one list
+ * refreshing next to one that did not. See ADR-0025.
+ *
  * @param stack - The name of the stack to query.
  * @param sql - The SQL query string.
- * @param params - Optional parameters for the SQL query.
- * @returns Object containing the query result (rows and AST), loading state, and error.
+ * @param params - Values for the query's `?` placeholders.
+ * @param options - See {@link QuerySQLOptions}; `{ live: false }` for a snapshot.
+ * @returns The query result (rows and AST), loading state, error, and `refetch`.
  *
  * @example
  * ```tsx
@@ -22,13 +28,25 @@ import { Document, SelectAST, UnionAST } from '@docstack/shared';
  * };
  * ```
  */
-export declare const useQuerySQL: (stack: string, sql: string, ...params: any[]) => {
+export type QuerySQLOptions = {
+    /**
+     * Re-run when a document changes in a class this query reads. Defaults to `true`.
+     *
+     * Pass `false` for a deliberate snapshot - and say so at the call site, which the
+     * previous behaviour never did.
+     */
+    live?: boolean;
+    /** Coalesce a burst of changes into one re-run, in milliseconds. Defaults to 150. */
+    coalesceMs?: number;
+};
+export declare const useQuerySQL: (stack: string, sql: string, params?: any[], options?: QuerySQLOptions) => {
     loading: boolean;
     result: {
         rows: any[];
         ast: (SelectAST | UnionAST)[] | null;
     };
-    error: null;
+    error: any;
+    refetch: () => Promise<void>;
 };
 /**
  * Hook to find documents in a stack using a Mango selector.