@effect-app/vue 4.0.0-beta.271 → 4.0.0-beta.273

package/dist/query.js

@@ -3,147 +3,258 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { experimental_streamedQuery as streamedQuery, useQuery as useTanstackQuery, useQueryClient } from "@tanstack/vue-query";
+import { injectRegistry, useAtomValue } from "@effect/atom-vue";
 import * as Array from "effect-app/Array";
 import { makeQueryKey } from "effect-app/client";
-import { CauseException, ServiceUnavailableError } from "effect-app/client/errors";
 import * as Effect from "effect-app/Effect";
 import * as Option from "effect-app/Option";
-import * as S from "effect-app/Schema";
-import * as Cause from "effect/Cause";
-import * as Channel from "effect/Channel";
 import * as Exit from "effect/Exit";
-import * as Pull from "effect/Pull";
-import * as Scope from "effect/Scope";
-import { isHttpClientError } from "effect/unstable/http/HttpClientError";
+import * as Stream from "effect/Stream";
 import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
-import { computed, ref, shallowRef, watch } from "vue";
-import { reportRuntimeError } from "./lib.js";
-import { makeRunPromise } from "./runtime.js";
-function swrToQuery(r) {
-    if (r.error !== undefined) {
-        return AsyncResult.failureWithPrevious(r.error.originalCause, {
-            previous: r.data === undefined ? Option.none() : Option.some(AsyncResult.success(r.data)),
-            waiting: r.isValidating
-        });
+import * as Atom from "effect/unstable/reactivity/Atom";
+import { computed, onBeforeUnmount, onMounted, ref, toValue } from "vue";
+import { awaitAtomResult, buildQueryFamily, buildStreamQueryFamily, disabledQueryAtom, isStaleResult, staleTimeMsOf, withQueryOptions } from "./atomQuery.js";
+const queryFamilyCacheKey = (q) => `${makeQueryKey(q).join("/")}:${q.queryKeyProjectionHash ?? ""}`;
+// One atom family per request shape, keyed by the stable query key + projection hash (not the
+// handler object — `clientFor` returns a fresh proxy per call, so the object isn't shareable).
+// Module-level + key-indexed => the family is process-global, so the same request+input read
+// the same atom across components/pages => cross-page caching via the global registry.
+const queryFamilyByKey = new Map();
+const getQueryFamily = (rt, q) => {
+    const key = queryFamilyCacheKey(q);
+    let f = queryFamilyByKey.get(key);
+    if (!f) {
+        f = buildQueryFamily(rt, q);
+        queryFamilyByKey.set(key, f);
     }
-    if (r.data !== undefined) {
-        return AsyncResult.success(r.data, { waiting: r.isValidating });
+    return f;
+};
+const streamQueryFamilyByKey = new Map();
+const getStreamQueryFamily = (rt, q) => {
+    const key = queryFamilyCacheKey(q);
+    let f = streamQueryFamilyByKey.get(key);
+    if (!f) {
+        f = buildStreamQueryFamily(rt, q);
+        streamQueryFamilyByKey.set(key, f);
     }
-    return AsyncResult.initial(r.isValidating);
-}
-function streamToAsyncIterableWithCauseException(self, context, id) {
+    return f;
+};
+const normalizeQueryOptions = (options) => {
+    const out = {};
+    if (options?.staleTime !== undefined)
+        out.staleTime = options.staleTime;
+    const gcTime = options?.idleTTL ?? options?.gcTime;
+    if (gcTime !== undefined)
+        out.gcTime = gcTime;
+    const revalidateOnFocus = options?.revalidateOnFocus ?? options?.refetchOnWindowFocus;
+    if (revalidateOnFocus !== undefined)
+        out.revalidateOnFocus = revalidateOnFocus;
+    if (options?.structuralSharing !== undefined)
+        out.structuralSharing = options.structuralSharing;
+    const refetchInterval = options?.refreshEvery ?? options?.refetchInterval;
+    if (refetchInterval !== undefined)
+        out.refetchInterval = refetchInterval;
+    return out;
+};
+export const useAtomQuery = (atom) => {
+    const registry = injectRegistry();
+    const atomRef = computed(atom);
+    const atomResult = useAtomValue(() => atomRef.value);
+    const result = computed(() => atomResult.value);
+    const refresh = () => registry.refresh(atomRef.value);
+    const awaitResult = () => awaitAtomResult(registry, atomRef.value);
+    const refetch = () => Effect.gen(function* () {
+        refresh();
+        return yield* awaitResult();
+    });
+    const data = computed(() => Option.getOrUndefined(AsyncResult.value(result.value)));
     return {
-        [Symbol.asyncIterator]() {
-            const runPromise = Effect.runPromiseWith(context);
-            const runPromiseExit = Effect.runPromiseExitWith(context);
-            const scope = Scope.makeUnsafe();
-            let pull;
-            let currentIter;
-            return {
-                async next() {
-                    if (currentIter) {
-                        const next = currentIter.next();
-                        if (!next.done)
-                            return next;
-                        currentIter = undefined;
-                    }
-                    pull ??= await runPromise(Channel.toPullScoped(self.channel, scope));
-                    const exit = await runPromiseExit(pull);
-                    if (Exit.isSuccess(exit)) {
-                        currentIter = exit.value[Symbol.iterator]();
-                        return currentIter.next();
-                    }
-                    else if (Pull.isDoneCause(exit.cause)) {
-                        return { done: true, value: undefined };
-                    }
-                    throw new CauseException(exit.cause, id);
-                },
-                return(_) {
-                    return runPromise(Effect.as(Scope.close(scope, Exit.void), { done: true, value: undefined }));
-                }
-            };
-        }
+        result,
+        data,
+        awaitResult,
+        refetch,
+        refresh,
+        registry,
+        atom: atomRef
     };
-}
-export const makeQuery = (getRuntime) => {
-    const useQuery_ = (q) => (arg, 
-    // todo QueryKey type would be [string, ...string[]], but with I it would be [string, ...string[], I]
-    options
-    // TODO
-    ) => {
-        // we wrap into CauseException because we want to keep the full cause of the failure.
-        const runPromise = makeRunPromise(getRuntime());
-        const arr = arg;
-        let req;
-        let callerOptions = options;
-        if (options?.mode === "optional") {
-            const getOption = typeof arr === "function"
-                ? arr
-                : () => arr.value;
-            req = {
-                get value() {
-                    // getOrUndefined returns undefined when None, but queryFn is only called when enabled (Some)
-                    return Option.getOrUndefined(getOption());
-                }
-            };
-            const { mode: _mode, enabled: _enabled, ...rest } = options ?? {};
-            callerOptions = { ...rest, enabled: computed(() => Option.isSome(getOption())) };
+};
+export const useAtomSuspense = (atom) => {
+    const view = useAtomQuery(atom);
+    const data = computed(() => {
+        const latest = view.data.value;
+        if (latest === undefined) {
+            throw new Error("Internal Error: atom suspense resolved without a latest value");
         }
-        else {
-            req = !arg
-                ? undefined
-                : typeof arr === "function"
-                    ? ({
-                        get value() {
-                            return arr();
-                        }
-                    })
-                    : ref(arg);
+        return latest;
+    });
+    const isMounted = ref(true);
+    onBeforeUnmount(() => {
+        isMounted.value = false;
+    });
+    const eff = Effect.gen(function* () {
+        const exit = yield* view.awaitResult().pipe(Effect.exit);
+        if (!isMounted.value) {
+            return yield* Effect.interrupt;
         }
-        const queryKey = makeQueryKey(q);
-        const projectionHash = q.queryKeyProjectionHash;
-        const defaultOptions = {
-            // we do not want to throw errors, because we turn the success and error responses into a Result type
-            // why don't we turn the error/success response into a Result type before returning to tanstack query? because we want to leverage tanstack query's retry and caching mechanism, which relies on throwing errors to trigger retries, and we don't want to interfere with that by catching the errors too early.
-            // but if we allow tanstack query to throw, it will trigger the error boundary in Vue - via a "watcher callback" error - which we currently report and log, which is not what we want.
-            // TODO: we might want to rethink the strategy of how to handle errors that happen after the initial load.
-            // For suspense, the initial load is captured by the suspense boundary.
-            // For subsequent loads (or non suspense use) we currently are required to use the QueryResult component to conditionally render error/loading/etc.
-            throwOnError: false
+        if (Exit.isFailure(exit)) {
+            return yield* Exit.failCause(exit.cause);
+        }
+        const fetch = (_options) => view.refetch();
+        const handle = {
+            awaitResult: view.awaitResult,
+            refetch: view.refetch,
+            refresh: view.refresh,
+            registry: view.registry,
+            atom: view.atom
         };
-        const r = useTanstackQuery({
-            ...defaultOptions,
-            ...callerOptions,
-            retry: (retryCount, error) => {
-                if (error instanceof CauseException) {
-                    if (!isHttpClientError(error.cause) && !S.is(ServiceUnavailableError)(error.cause)) {
-                        return false;
-                    }
+        return Object.assign([
+            view.result,
+            data,
+            fetch,
+            handle
+        ], {
+            ...view,
+            data
+        });
+    });
+    return Effect.runPromise(eff);
+};
+export const useAtomStreamQuery = (atom) => {
+    const registry = injectRegistry();
+    const atomRef = computed(atom);
+    const atomResult = useAtomValue(() => atomRef.value);
+    const result = computed(() => atomResult.value);
+    const pull = () => registry.set(atomRef.value, void 0);
+    const refresh = () => registry.refresh(atomRef.value);
+    const awaitResult = () => awaitAtomResult(registry, atomRef.value);
+    const pullAndAwait = () => Effect.gen(function* () {
+        pull();
+        return yield* awaitResult();
+    });
+    const items = computed(() => Option.getOrElse(Option.map(AsyncResult.value(result.value), (_) => _.items), () => []));
+    const latest = computed(() => items.value.at(-1));
+    const done = computed(() => Option.getOrElse(Option.map(AsyncResult.value(result.value), (_) => _.done), () => false));
+    return {
+        result,
+        items,
+        latest,
+        done,
+        awaitResult,
+        pull,
+        pullAndAwait,
+        refresh,
+        registry,
+        atom: atomRef
+    };
+};
+const optionValue = (arr, options) => {
+    if (options?.mode === "optional") {
+        const getOption = typeof arr === "function"
+            ? arr
+            : () => arr.value;
+        return [
+            {
+                get value() {
+                    return Option.getOrUndefined(getOption());
                 }
-                return retryCount < 5;
             },
-            queryKey: projectionHash === undefined ? [...queryKey, req] : [...queryKey, req, projectionHash],
-            queryFn: ({ meta, signal }) => runPromise(q
-                .handler(req?.value)
-                .pipe(Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause)), Effect.withSpan(`query ${q.id}`, {}, { captureStackTrace: false }), meta?.["span"] ? Effect.withParentSpan(meta["span"]) : (_) => _), { signal })
-        });
-        const latestSuccess = shallowRef();
-        const result = computed(() => swrToQuery({
-            error: r.error.value ?? undefined,
-            data: r.data.value === undefined ? latestSuccess.value : r.data.value, // we fall back to existing data, as tanstack query might loose it when the key changes
-            isValidating: r.isFetching.value
-        }));
-        // not using `computed` here as we have a circular dependency
-        watch(result, (value) => latestSuccess.value = Option.getOrUndefined(AsyncResult.value(value)), { immediate: true });
+            computed(() => Option.isSome(getOption()))
+        ];
+    }
+    const req = !arr
+        ? ({ value: undefined })
+        : typeof arr === "function"
+            ? ({
+                get value() {
+                    return arr();
+                }
+            })
+            : ref(arr);
+    const enabled = options?.enabled;
+    return [req, computed(() => enabled === undefined ? true : !!toValue(enabled))];
+};
+const observedAtom = (atom, options) => withQueryOptions(atom, normalizeQueryOptions(options));
+const observedStreamAtom = (atom, options) => {
+    let next = atom;
+    const refetchInterval = options?.refreshEvery ?? options?.refetchInterval;
+    if (refetchInterval !== undefined)
+        next = Atom.withRefresh(refetchInterval)(next);
+    const gcTime = options?.idleTTL ?? options?.gcTime;
+    if (gcTime === "infinity")
+        return Atom.keepAlive(next);
+    if (gcTime !== undefined)
+        return Atom.setIdleTTL(next, gcTime);
+    return next;
+};
+const queryAtomFor = (rt, q, arg, options) => {
+    const family = getQueryFamily(rt, q);
+    return observedAtom(family(arg), options);
+};
+const makeQueryView = (getAtomRt, q, arg, options) => {
+    const atomRt = getAtomRt();
+    const registry = injectRegistry();
+    const [req, enabledRef] = optionValue(arg, options);
+    const family = getQueryFamily(atomRt, q);
+    const atomRef = computed(() => enabledRef.value ? observedAtom(family(req.value), options) : disabledQueryAtom);
+    const rawResult = useAtomValue(() => atomRef.value);
+    const select = options?.select;
+    const result = (select
+        ? computed(() => AsyncResult.map(rawResult.value, select))
+        : rawResult);
+    const refresh = () => registry.refresh(atomRef.value);
+    const awaitResult = () => select
+        ? awaitAtomResult(registry, atomRef.value).pipe(Effect.map(select))
+        : awaitAtomResult(registry, atomRef.value);
+    const refetch = () => Effect.gen(function* () {
+        refresh();
+        return yield* awaitResult();
+    });
+    const staleMs = staleTimeMsOf(normalizeQueryOptions(options));
+    onMounted(() => {
+        if (!enabledRef.value)
+            return;
+        if (isStaleResult(registry.get(atomRef.value), staleMs))
+            refresh();
+    });
+    const data = computed(() => Option.getOrUndefined(AsyncResult.value(result.value)));
+    return {
+        result,
+        data,
+        awaitResult,
+        refetch,
+        refresh,
+        registry,
+        atom: atomRef
+    };
+};
+export const makeQueryFamily = (_getRuntime, getAtomRt) => {
+    const useQueryFamily = (q) => getQueryFamily(getAtomRt(), q);
+    return useQueryFamily;
+};
+export const makeQueryAtom = (_getRuntime, getAtomRt) => {
+    const useQueryAtom = (q) => (arg, options) => queryAtomFor(getAtomRt(), q, arg, options);
+    return useQueryAtom;
+};
+export const makeQueryNew = (_getRuntime, getAtomRt) => {
+    const useQueryNew = (q) => (arg, options) => makeQueryView(getAtomRt, q, arg, options);
+    return useQueryNew;
+};
+export const makeQuery = (_getRuntime, getAtomRt) => {
+    const useQuery_ = (q) => (arg, options) => {
+        const view = makeQueryView(getAtomRt, q, arg, options);
+        // 4th element is internal-only; the public `.suspense()` Promise boundary lives in makeClient.
+        const handle = {
+            awaitResult: view.awaitResult,
+            refetch: view.refetch,
+            refresh: view.refresh,
+            registry: view.registry,
+            atom: view.atom
+        };
         return [
-            result,
-            computed(() => latestSuccess.value),
-            // one thing to keep in mind is that span will be disconnected as Context does not pass from outside.
-            // TODO: consider how we should handle the Result here which is `QueryObserverResult<A, E>`
-            // and always ends up in the success channel, even when error..
-            (options) => Effect.currentSpan.pipe(Effect.orElseSucceed(() => null), Effect.flatMap((span) => Effect.promise(() => r.refetch({ ...options, updateMeta: { span } })))),
-            r
+            view.result,
+            view.data,
+            (_options) => view.refetch(),
+            handle
         ];
     };
     const useQuery = ((self) => {
@@ -152,51 +263,35 @@ export const makeQuery = (getRuntime) => {
     });
     return useQuery;
 };
-export const makeStreamQuery = (getRuntime) => {
-    const streamQuery_ = (q) => (arg) => {
-        const context = getRuntime();
-        const arr = arg;
-        const req = !arg
-            ? undefined
-            : typeof arr === "function"
-                ? ({
-                    get value() {
-                        return arr();
-                    }
-                })
-                : ref(arg);
-        const queryKey = makeQueryKey(q);
-        const r = useTanstackQuery({
-            throwOnError: false,
-            retry: (retryCount, error) => {
-                if (error instanceof CauseException) {
-                    if (!isHttpClientError(error.cause) && !S.is(ServiceUnavailableError)(error.cause)) {
-                        return false;
-                    }
-                }
-                return retryCount < 5;
-            },
-            queryKey: [...queryKey, req],
-            queryFn: streamedQuery({
-                streamFn: () => {
-                    const stream = q.handler(req?.value);
-                    return streamToAsyncIterableWithCauseException(stream, context, q.id);
-                }
-            })
+const streamQueryAtomFor = (rt, q, arg, options) => {
+    const family = getStreamQueryFamily(rt, q);
+    return observedStreamAtom(family(arg), options);
+};
+export const makeStreamQueryFamily = (_getRuntime, getAtomRt) => {
+    const useStreamQueryFamily = (q) => getStreamQueryFamily(getAtomRt(), q);
+    return useStreamQueryFamily;
+};
+export const makeStreamQueryAtom = (_getRuntime, getAtomRt) => {
+    const useStreamQueryAtom = (q) => (arg, options) => streamQueryAtomFor(getAtomRt(), q, arg, options);
+    return useStreamQueryAtom;
+};
+export const makeStreamQueryNew = (_getRuntime, getAtomRt) => {
+    const useStreamQueryNew = (q) => (arg, options) => useAtomStreamQuery(() => streamQueryAtomFor(getAtomRt(), q, toValue(arg), options));
+    return useStreamQueryNew;
+};
+export const makeStreamQuery = (getRuntime, getAtomRt) => {
+    const query = makeQuery(getRuntime, getAtomRt);
+    // A stream query is an ordinary atom query over an effect that collects the whole stream
+    // into an array (`Stream.runCollect`). It reuses all the atom machinery (family cache, swr,
+    // invalidation, structural sharing). Note: unlike the old tanstack `streamedQuery`, the result
+    // appears once the stream completes, not incrementally (stream queries are not used today).
+    const streamQuery_ = (q) => {
+        const hook = query({
+            id: q.id,
+            options: q.options,
+            handler: (i) => Stream.runCollect(q.handler(i)).pipe(Effect.map((chunk) => [...chunk]))
         });
-        const latestSuccess = shallowRef();
-        const result = computed(() => swrToQuery({
-            error: r.error.value ?? undefined,
-            data: r.data.value === undefined ? latestSuccess.value : r.data.value,
-            isValidating: r.isFetching.value
-        }));
-        watch(result, (value) => latestSuccess.value = Option.getOrUndefined(AsyncResult.value(value)), { immediate: true });
-        return [
-            result,
-            computed(() => latestSuccess.value),
-            (options) => Effect.currentSpan.pipe(Effect.orElseSucceed(() => null), Effect.flatMap((span) => Effect.promise(() => r.refetch({ ...options, updateMeta: { span } })))),
-            r
-        ];
+        return (arg) => hook(arg);
     };
     return streamQuery_;
 };
@@ -229,17 +324,18 @@ export function composeQueries(results, renderPreviousOnFailure) {
     return AsyncResult.success(r, { waiting: isRefreshing });
 }
 export const useUpdateQuery = () => {
-    const queryClient = useQueryClient();
-    const f = (query, input, updater) => {
-        const key = [...makeQueryKey(query), input];
-        const data = queryClient.getQueryData(key);
-        if (data) {
-            queryClient.setQueryData(key, updater);
-        }
-        else {
-            console.warn(`Query data for key ${key} not found`, key);
+    const registry = injectRegistry();
+    // NOTE: query atoms are derived (read-only) here, so unlike tanstack's `setQueryData` we can't
+    // optimistically patch the cache in place — this refetches the query (the `updater` is ignored).
+    // A first-class optimistic-update layer is planned for the atom-native redesign.
+    const f = (query, input, _updater) => {
+        const family = queryFamilyByKey.get(queryFamilyCacheKey(query));
+        if (!family) {
+            console.warn(`Query ${query.id} has not been used yet; nothing to update`);
+            return;
         }
+        registry.refresh(family(input));
     };
     return f;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.js","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.js","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"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"}