@rikalabs/effect-react 0.0.1

package/dist/query/index.cjs

@@ -0,0 +1,361 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/query/index.ts
+var query_exports = {};
+__export(query_exports, {
+  QueryRuntimeError: () => QueryRuntimeError,
+  defineQuery: () => defineQuery,
+  fetchQuery: () => fetchQuery2,
+  invalidate: () => invalidate,
+  invalidateQuery: () => invalidateQuery,
+  prefetch: () => prefetch,
+  prefetchQuery: () => prefetchQuery,
+  useInfiniteQuery: () => useInfiniteQuery,
+  useQuery: () => useQuery2,
+  useSuspenseQuery: () => useSuspenseQuery2
+});
+module.exports = __toCommonJS(query_exports);
+
+// src/data/types.ts
+var defineQuery = (definition) => definition;
+var QueryRuntimeError = class extends Error {
+  constructor(messageText) {
+    super(messageText);
+    this.messageText = messageText;
+    this.name = "QueryRuntimeError";
+  }
+  _tag = "QueryRuntimeError";
+};
+
+// src/query/service.ts
+var import_effect3 = require("effect");
+
+// src/data/service.ts
+var import_effect = require("effect");
+var Data = class extends import_effect.Context.Tag("EffectReact/Data")() {
+};
+var fetchQuery = (definition, input, options) => import_effect.Effect.flatMap(Data, (service) => service.fetch(definition, input, options));
+
+// src/data/react.tsx
+var import_effect2 = require("effect");
+var import_react2 = require("react");
+
+// src/react/provider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var RuntimeContext = (0, import_react.createContext)(null);
+var useEffectRuntime = () => {
+  const runtime = (0, import_react.useContext)(RuntimeContext);
+  if (runtime === null) {
+    throw new Error("Effect runtime is not available. Wrap your app with <EffectProvider>.");
+  }
+  return runtime;
+};
+
+// src/data/react.tsx
+var useDataService = () => {
+  const runtime = useEffectRuntime();
+  return (0, import_react2.useMemo)(() => runtime.runSync(Data), [runtime]);
+};
+var useQuery = (definition, input, options = {}) => {
+  const runtime = useEffectRuntime();
+  const data = useDataService();
+  const subscribe = (0, import_react2.useCallback)(
+    (listener) => {
+      const fiber = runtime.runFork(
+        import_effect2.Stream.runForEach(data.snapshots, () => import_effect2.Effect.sync(listener))
+      );
+      return () => {
+        runtime.runFork(import_effect2.Fiber.interrupt(fiber));
+      };
+    },
+    [data, runtime]
+  );
+  const getSnapshot = (0, import_react2.useCallback)(
+    () => runtime.runSync(data.getSnapshot(definition, input)),
+    [data, definition, input, runtime]
+  );
+  const snapshot = (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  (0, import_react2.useEffect)(() => {
+    if (options.enabled === false) {
+      return;
+    }
+    runtime.runFork(data.prefetch(definition, input));
+  }, [data, definition, input, options.enabled, runtime]);
+  const refetch = (0, import_react2.useCallback)(
+    () => runtime.runPromise(data.fetch(definition, input, { ...options.run, forceRefresh: true })),
+    [data, definition, input, options.run, runtime]
+  );
+  const invalidate2 = (0, import_react2.useCallback)(
+    () => runtime.runPromise(data.invalidate(definition, input)),
+    [data, definition, input, runtime]
+  );
+  return {
+    ...snapshot,
+    refetch,
+    invalidate: invalidate2
+  };
+};
+var useSuspenseQuery = (definition, input) => {
+  const result = useQuery(definition, input);
+  if (result.phase === "failure") {
+    throw result.error;
+  }
+  if (result.phase === "success") {
+    return result.data;
+  }
+  throw result.refetch();
+};
+
+// src/query/service.ts
+var fetchQuery2 = fetchQuery;
+var prefetchQuery = (definition, input) => import_effect3.Effect.flatMap(Data, (service) => service.prefetch(definition, input));
+var invalidateQuery = (definition, input) => import_effect3.Effect.flatMap(Data, (service) => service.invalidate(definition, input));
+var prefetch = prefetchQuery;
+var invalidate = invalidateQuery;
+
+// src/query/react.tsx
+var import_effect4 = require("effect");
+var import_react3 = require("react");
+var upsertInfiniteEntry = (entries, nextEntry) => {
+  const index = entries.findIndex((entry) => entry.key === nextEntry.key);
+  if (index < 0) {
+    return [...entries, nextEntry];
+  }
+  const next = [...entries];
+  next[index] = nextEntry;
+  return next;
+};
+var useDataService2 = () => {
+  const runtime = useEffectRuntime();
+  return (0, import_react3.useMemo)(() => runtime.runSync(Data), [runtime]);
+};
+var useQuery2 = (definition, input, options = {}) => useQuery(definition, input, options);
+var useSuspenseQuery2 = (definition, input) => useSuspenseQuery(definition, input);
+var useInfiniteQuery = (definition, options) => {
+  const optionsRef = (0, import_react3.useRef)(options);
+  optionsRef.current = options;
+  const initialPageParam = options.initialPageParam;
+  const enabled = options.enabled;
+  const run = options.run;
+  const getInput = (0, import_react3.useCallback)(
+    (pageParam) => optionsRef.current.getInput(pageParam),
+    []
+  );
+  const getNextPageParam = (0, import_react3.useCallback)(
+    (lastPage, allPages, lastPageParam, allPageParams) => optionsRef.current.getNextPageParam(lastPage, allPages, lastPageParam, allPageParams),
+    []
+  );
+  const runtime = useEffectRuntime();
+  const data = useDataService2();
+  const [initialInput, setInitialInput] = (0, import_react3.useState)(
+    () => getInput(initialPageParam)
+  );
+  const [entries, setEntries] = (0, import_react3.useState)([]);
+  const [error, setError] = (0, import_react3.useState)(void 0);
+  const [isFetchingNextPage, setIsFetchingNextPage] = (0, import_react3.useState)(false);
+  const initialQuery = useQuery2(
+    definition,
+    initialInput,
+    {
+      ...enabled !== void 0 ? { enabled } : {},
+      ...run !== void 0 ? { run } : {}
+    }
+  );
+  (0, import_react3.useEffect)(() => {
+    setInitialInput(getInput(initialPageParam));
+    setEntries([]);
+    setError(void 0);
+    setIsFetchingNextPage(false);
+  }, [definition, getInput, initialPageParam]);
+  (0, import_react3.useEffect)(() => {
+    if (initialQuery.phase === "success") {
+      setEntries(
+        (current) => upsertInfiniteEntry(current, {
+          key: initialQuery.key,
+          pageParam: initialPageParam,
+          data: initialQuery.data
+        })
+      );
+      setError(void 0);
+      return;
+    }
+    if (initialQuery.phase === "failure") {
+      setError(initialQuery.error);
+    }
+  }, [
+    initialQuery.data,
+    initialQuery.error,
+    initialQuery.key,
+    initialQuery.phase,
+    initialPageParam
+  ]);
+  const pages = (0, import_react3.useMemo)(() => entries.map((entry) => entry.data), [entries]);
+  const pageParams = (0, import_react3.useMemo)(() => entries.map((entry) => entry.pageParam), [entries]);
+  const resolveNextPageParam = (0, import_react3.useCallback)(() => {
+    const lastEntry = entries[entries.length - 1];
+    if (lastEntry !== void 0) {
+      return getNextPageParam(lastEntry.data, pages, lastEntry.pageParam, pageParams);
+    }
+    if (initialQuery.phase !== "success") {
+      return void 0;
+    }
+    const initialPage = initialQuery.data;
+    return getNextPageParam(
+      initialPage,
+      [initialPage],
+      initialPageParam,
+      [initialPageParam]
+    );
+  }, [
+    entries,
+    getNextPageParam,
+    initialPageParam,
+    initialQuery.data,
+    initialQuery.phase,
+    pageParams,
+    pages
+  ]);
+  const fetchNextPage = (0, import_react3.useCallback)(() => {
+    const nextPageParam = resolveNextPageParam();
+    if (nextPageParam === void 0) {
+      return runtime.runPromise(import_effect4.Effect.succeed(void 0));
+    }
+    setIsFetchingNextPage(true);
+    setError(void 0);
+    const input = getInput(nextPageParam);
+    const program = import_effect4.Effect.gen(function* () {
+      const value = yield* data.fetch(definition, input, run);
+      const snapshot = yield* data.getSnapshot(definition, input);
+      return {
+        key: snapshot.key,
+        pageParam: nextPageParam,
+        value
+      };
+    });
+    return runtime.runPromise(program).then(
+      ({ key, pageParam, value }) => {
+        setEntries(
+          (current) => upsertInfiniteEntry(current, {
+            key,
+            pageParam,
+            data: value
+          })
+        );
+        setIsFetchingNextPage(false);
+        return value;
+      },
+      (cause) => {
+        setIsFetchingNextPage(false);
+        const resolved = cause;
+        setError(resolved);
+        return runtime.runPromise(import_effect4.Effect.fail(resolved));
+      }
+    );
+  }, [data, definition, getInput, resolveNextPageParam, run, runtime]);
+  const refetch = (0, import_react3.useCallback)(() => {
+    const targets = pageParams.length === 0 ? [initialPageParam] : pageParams;
+    setError(void 0);
+    const program = import_effect4.Effect.forEach(
+      targets,
+      (pageParam) => {
+        const input = getInput(pageParam);
+        return import_effect4.Effect.gen(function* () {
+          const value = yield* data.fetch(definition, input, {
+            ...run,
+            forceRefresh: true
+          });
+          const snapshot = yield* data.getSnapshot(definition, input);
+          return {
+            key: snapshot.key,
+            pageParam,
+            data: value
+          };
+        });
+      },
+      {
+        concurrency: 1,
+        discard: false
+      }
+    );
+    return runtime.runPromise(program).then(
+      (fetchedEntries) => {
+        setEntries(fetchedEntries);
+        return fetchedEntries.map((entry) => entry.data);
+      },
+      (cause) => {
+        const resolved = cause;
+        setError(resolved);
+        return runtime.runPromise(import_effect4.Effect.fail(resolved));
+      }
+    );
+  }, [data, definition, getInput, initialPageParam, pageParams, run, runtime]);
+  const invalidate2 = (0, import_react3.useCallback)(() => {
+    const targets = pageParams.length === 0 ? [initialPageParam] : pageParams;
+    const program = import_effect4.Effect.forEach(
+      targets,
+      (pageParam) => data.invalidate(definition, getInput(pageParam)),
+      {
+        concurrency: 1,
+        discard: true
+      }
+    );
+    return runtime.runPromise(program).then(
+      () => {
+        setEntries([]);
+        setError(void 0);
+        setIsFetchingNextPage(false);
+        return void 0;
+      },
+      (cause) => {
+        const resolved = cause;
+        setError(resolved);
+        return runtime.runPromise(import_effect4.Effect.fail(resolved));
+      }
+    );
+  }, [data, definition, getInput, initialPageParam, pageParams, runtime]);
+  const resolvedError = error ?? (initialQuery.phase === "failure" ? initialQuery.error : void 0);
+  const phase = resolvedError !== void 0 ? "failure" : entries.length > 0 ? "success" : initialQuery.phase;
+  return {
+    phase,
+    pages,
+    pageParams,
+    error: resolvedError,
+    hasNextPage: resolveNextPageParam() !== void 0,
+    isFetchingNextPage,
+    fetchNextPage,
+    refetch,
+    invalidate: invalidate2
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueryRuntimeError,
+  defineQuery,
+  fetchQuery,
+  invalidate,
+  invalidateQuery,
+  prefetch,
+  prefetchQuery,
+  useInfiniteQuery,
+  useQuery,
+  useSuspenseQuery
+});
+//# sourceMappingURL=index.cjs.map

package/dist/query/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/query/index.ts","../../src/data/types.ts","../../src/query/service.ts","../../src/data/service.ts","../../src/data/react.tsx","../../src/react/provider.tsx","../../src/query/react.tsx"],"sourcesContent":["export * from \"./types\";\nexport * from \"./service\";\nexport * from \"./react\";\n","import type { Duration, Effect, Schema } from \"effect\";\nimport type { BoundaryDecodeError } from \"../boundary\";\nimport type { BoundaryProtocolError } from \"../boundary/errors\";\n\nexport interface QueryDefinition<\n  Name extends string,\n  Input,\n  Output,\n  E,\n  InputEncoded = Input,\n  OutputEncoded = Output,\n> {\n  readonly name: Name;\n  readonly input: Schema.Schema<Input, InputEncoded, never>;\n  readonly output: Schema.Schema<Output, OutputEncoded, never>;\n  readonly run: (input: Input) => Effect.Effect<Output, E, never>;\n  readonly key?: (input: Input) => unknown;\n}\n\nexport const defineQuery = <\n  Name extends string,\n  Input,\n  Output,\n  E,\n  InputEncoded = Input,\n  OutputEncoded = Output,\n>(\n  definition: QueryDefinition<Name, Input, Output, E, InputEncoded, OutputEncoded>,\n): QueryDefinition<Name, Input, Output, E, InputEncoded, OutputEncoded> => definition;\n\nexport type QueryPhase = \"initial\" | \"loading\" | \"success\" | \"failure\";\n\nexport interface QuerySnapshot<Output, E> {\n  readonly key: string;\n  readonly phase: QueryPhase;\n  readonly data: Output | undefined;\n  readonly error: E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError | undefined;\n  readonly updatedAt: number | null | undefined;\n}\n\nexport interface QueryRunOptions {\n  readonly forceRefresh?: boolean;\n}\n\nexport interface QueryRuntimeOptions {\n  readonly capacity?: number;\n  readonly timeToLive?: Duration.DurationInput;\n}\n\nexport class QueryRuntimeError extends Error {\n  readonly _tag = \"QueryRuntimeError\" as const;\n\n  constructor(readonly messageText: string) {\n    super(messageText);\n    this.name = \"QueryRuntimeError\";\n  }\n}\n","import { Effect } from \"effect\";\nimport { Data, fetchQuery as fetchDataQuery } from \"../data\";\nimport type { BoundaryDecodeError } from \"../boundary\";\nimport type { BoundaryProtocolError } from \"../boundary/errors\";\nimport type { QueryDefinition, QueryRuntimeError } from \"./types\";\n\nexport const fetchQuery = fetchDataQuery;\n\nexport const prefetchQuery = <Name extends string, Input, Output, E>(\n  definition: QueryDefinition<Name, Input, Output, E>,\n  input: unknown,\n): Effect.Effect<void, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, Data> =>\n  Effect.flatMap(Data, (service) => service.prefetch(definition, input));\n\nexport const invalidateQuery = <Name extends string, Input, Output, E>(\n  definition: QueryDefinition<Name, Input, Output, E>,\n  input: unknown,\n): Effect.Effect<void, QueryRuntimeError, Data> =>\n  Effect.flatMap(Data, (service) => service.invalidate(definition, input));\n\nexport const prefetch = prefetchQuery;\nexport const invalidate = invalidateQuery;\n","import {\n  Cache,\n  Context,\n  Effect,\n  Layer,\n  SubscriptionRef,\n  type Stream,\n} from \"effect\";\nimport { Boundary, type BoundaryDecodeError } from \"../boundary\";\nimport type { BoundaryProtocolError } from \"../boundary/errors\";\nimport { Telemetry } from \"../kernel/telemetry\";\nimport {\n  type QueryDefinition,\n  type QueryRunOptions,\n  type QueryRuntimeOptions,\n  type QuerySnapshot,\n  QueryRuntimeError,\n} from \"./types\";\n\nconst defaultRuntimeOptions: Required<QueryRuntimeOptions> = {\n  capacity: 2048,\n  timeToLive: \"5 minutes\",\n};\n\nconst stableStringify = (value: unknown): string => {\n  if (value === null || value === undefined) {\n    return String(value);\n  }\n\n  if (typeof value !== \"object\") {\n    return JSON.stringify(value);\n  }\n\n  if (Array.isArray(value)) {\n    return `[${value.map(stableStringify).join(\",\")}]`;\n  }\n\n  const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) =>\n    a.localeCompare(b),\n  );\n  return `{${entries.map(([key, nested]) => `${JSON.stringify(key)}:${stableStringify(nested)}`).join(\",\")}}`;\n};\n\nconst initialSnapshot = <Output, E>(key: string): QuerySnapshot<Output, E> => ({\n  key,\n  phase: \"initial\",\n  data: undefined,\n  error: undefined,\n  updatedAt: null,\n});\n\nexport interface DataService {\n  readonly fetch: <Name extends string, Input, Output, E>(\n    definition: QueryDefinition<Name, Input, Output, E>,\n    input: unknown,\n    options?: QueryRunOptions,\n  ) => Effect.Effect<Output, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, never>;\n  readonly prefetch: <Name extends string, Input, Output, E>(\n    definition: QueryDefinition<Name, Input, Output, E>,\n    input: unknown,\n  ) => Effect.Effect<void, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, never>;\n  readonly invalidate: <Name extends string, Input, Output, E>(\n    definition: QueryDefinition<Name, Input, Output, E>,\n    input: unknown,\n  ) => Effect.Effect<void, QueryRuntimeError, never>;\n  readonly getSnapshot: <Name extends string, Input, Output, E>(\n    definition: QueryDefinition<Name, Input, Output, E>,\n    input: unknown,\n  ) => Effect.Effect<QuerySnapshot<Output, E>, never, never>;\n  readonly getAllSnapshots: Effect.Effect<ReadonlyMap<string, QuerySnapshot<unknown, unknown>>, never, never>;\n  readonly hydrateSnapshots: (\n    snapshots: ReadonlyMap<string, QuerySnapshot<unknown, unknown>>,\n  ) => Effect.Effect<void, never, never>;\n  readonly snapshots: Stream.Stream<ReadonlyMap<string, QuerySnapshot<unknown, unknown>>>;\n}\n\nexport class Data extends Context.Tag(\"EffectReact/Data\")<Data, DataService>() {}\n\nexport const makeDataLayer = (\n  options: QueryRuntimeOptions = {},\n): Layer.Layer<Data, never, Boundary | Telemetry> => {\n  const merged = {\n    ...defaultRuntimeOptions,\n    ...options,\n  };\n\n  return Layer.effect(\n    Data,\n    Effect.gen(function* () {\n      const boundary = yield* Boundary;\n      const telemetry = yield* Telemetry;\n      const lookups = new Map<string, Effect.Effect<unknown, unknown, never>>();\n      const snapshots = yield* SubscriptionRef.make(\n        new Map<string, QuerySnapshot<unknown, unknown>>() as ReadonlyMap<\n          string,\n          QuerySnapshot<unknown, unknown>\n        >,\n      );\n\n      const cache = yield* Cache.make<string, unknown, unknown>({\n        capacity: merged.capacity,\n        timeToLive: merged.timeToLive,\n        lookup: (key) =>\n          Effect.suspend(() => {\n            const lookup = lookups.get(key);\n            if (lookup === undefined) {\n              return Effect.fail(new QueryRuntimeError(`No query executor registered for ${key}`));\n            }\n            return lookup;\n          }),\n      });\n\n      const setSnapshot = <Output, E>(\n        key: string,\n        update: (previous: QuerySnapshot<Output, E>) => QuerySnapshot<Output, E>,\n      ): Effect.Effect<void> =>\n        SubscriptionRef.update(snapshots, (current) => {\n          const next = new Map(current);\n          const previous =\n            (next.get(key) as QuerySnapshot<Output, E> | undefined) ?? initialSnapshot<Output, E>(key);\n          next.set(key, update(previous));\n          return next;\n        }).pipe(Effect.asVoid);\n\n      const buildKey = <Name extends string, Input, Output, E>(\n        definition: QueryDefinition<Name, Input, Output, E>,\n        input: Input,\n      ): string => {\n        const base = definition.key ? definition.key(input) : input;\n        return `${definition.name}:${stableStringify(base)}`;\n      };\n\n      const fetch = <Name extends string, Input, Output, E>(\n        definition: QueryDefinition<Name, Input, Output, E>,\n        input: unknown,\n        runOptions?: QueryRunOptions,\n      ): Effect.Effect<\n        Output,\n        E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError,\n        never\n      > =>\n        Effect.gen(function* () {\n          const decodedInput = yield* boundary.decodeUnknown({\n            source: `query:${definition.name}:input`,\n            schema: definition.input,\n            value: input,\n          });\n\n          const key = buildKey(definition, decodedInput);\n          yield* telemetry.emit({\n            _tag: \"query\",\n            phase: \"start\",\n            key,\n            timestamp: Date.now(),\n          });\n\n          yield* setSnapshot(key, (previous) => ({\n            ...previous,\n            phase: \"loading\",\n            error: undefined,\n          }));\n\n          lookups.set(\n            key,\n            definition\n              .run(decodedInput)\n              .pipe(\n                Effect.flatMap((output) =>\n                  boundary.decodeUnknown({\n                    source: `query:${definition.name}:output`,\n                    schema: definition.output,\n                    value: output,\n                  }),\n                ),\n              ) as Effect.Effect<unknown, unknown, never>,\n          );\n\n          if (runOptions?.forceRefresh === true) {\n            yield* cache.refresh(key).pipe(Effect.ignore);\n          }\n\n          const value = yield* cache.get(key).pipe(\n            Effect.mapError(\n              (error) =>\n                error as E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError,\n            ),\n          );\n\n          yield* setSnapshot(key, () => ({\n            key,\n            phase: \"success\",\n            data: value,\n            error: undefined,\n            updatedAt: Date.now(),\n          }));\n\n          yield* telemetry.emit({\n            _tag: \"query\",\n            phase: \"success\",\n            key,\n            timestamp: Date.now(),\n          });\n\n          return value as Output;\n        }).pipe(\n          Effect.tapError((error) =>\n            Effect.gen(function* () {\n              const decodedInput = yield* boundary.decodeUnknown({\n                source: `query:${definition.name}:input`,\n                schema: definition.input,\n                value: input,\n              });\n              const key = buildKey(definition, decodedInput);\n              yield* setSnapshot(key, (previous) => ({\n                ...previous,\n                phase: \"failure\",\n                error,\n                updatedAt: previous.updatedAt,\n              }));\n              yield* telemetry.emit({\n                _tag: \"query\",\n                phase: \"failure\",\n                key,\n                timestamp: Date.now(),\n                detail: error,\n              });\n            }),\n          ),\n        );\n\n      const prefetch: DataService[\"prefetch\"] = (definition, input) =>\n        fetch(definition, input).pipe(Effect.asVoid);\n\n      const invalidate: DataService[\"invalidate\"] = (definition, input) =>\n        Effect.gen(function* () {\n          const key = `${definition.name}:${stableStringify(input)}`;\n          yield* cache.invalidate(key);\n          yield* SubscriptionRef.update(snapshots, (current) => {\n            const next = new Map(current);\n            next.delete(key);\n            return next;\n          }).pipe(Effect.asVoid);\n          yield* telemetry.emit({\n            _tag: \"query\",\n            phase: \"invalidate\",\n            key,\n            timestamp: Date.now(),\n          });\n        });\n\n      const getSnapshot = <Name extends string, Input, Output, E>(\n        definition: QueryDefinition<Name, Input, Output, E>,\n        input: unknown,\n      ): Effect.Effect<QuerySnapshot<Output, E>, never, never> =>\n        Effect.gen(function* () {\n          const key = `${definition.name}:${stableStringify(input)}`;\n          const current = yield* SubscriptionRef.get(snapshots);\n          const snapshot = current.get(key);\n          if (snapshot === undefined) {\n            return initialSnapshot<Output, E>(key);\n          }\n          return snapshot as QuerySnapshot<Output, E>;\n        });\n\n      return {\n        fetch,\n        prefetch,\n        invalidate,\n        getSnapshot,\n        getAllSnapshots: SubscriptionRef.get(snapshots),\n        hydrateSnapshots: (nextSnapshots) => SubscriptionRef.set(snapshots, new Map(nextSnapshots)),\n        snapshots: snapshots.changes,\n      } satisfies DataService;\n    }),\n  );\n};\n\nexport const fetchQuery = <Name extends string, Input, Output, E>(\n  definition: QueryDefinition<Name, Input, Output, E>,\n  input: unknown,\n  options?: QueryRunOptions,\n): Effect.Effect<Output, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, Data> =>\n  Effect.flatMap(Data, (service) => service.fetch(definition, input, options));\n","import { Effect, Fiber, Stream } from \"effect\";\nimport { useCallback, useEffect, useMemo, useSyncExternalStore } from \"react\";\nimport { useEffectRuntime } from \"../react/provider\";\nimport { Data } from \"./service\";\nimport type { QueryDefinition, QueryRunOptions, QuerySnapshot } from \"./types\";\n\nconst useDataService = () => {\n  const runtime = useEffectRuntime();\n  return useMemo(() => runtime.runSync(Data), [runtime]);\n};\n\nexport interface UseQueryOptions {\n  readonly enabled?: boolean;\n  readonly run?: QueryRunOptions;\n}\n\nexport const useQuery = <Name extends string, Input, Output, E>(\n  definition: QueryDefinition<Name, Input, Output, E>,\n  input: unknown,\n  options: UseQueryOptions = {},\n): QuerySnapshot<Output, E> & {\n  readonly refetch: () => Promise<Output>;\n  readonly invalidate: () => Promise<void>;\n} => {\n  const runtime = useEffectRuntime();\n  const data = useDataService();\n\n  const subscribe = useCallback(\n    (listener: () => void) => {\n      const fiber = runtime.runFork(\n        Stream.runForEach(data.snapshots, () => Effect.sync(listener)),\n      );\n\n      return () => {\n        runtime.runFork(Fiber.interrupt(fiber));\n      };\n    },\n    [data, runtime],\n  );\n\n  const getSnapshot = useCallback(\n    () => runtime.runSync(data.getSnapshot(definition, input)) as QuerySnapshot<Output, E>,\n    [data, definition, input, runtime],\n  );\n\n  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n\n  useEffect(() => {\n    if (options.enabled === false) {\n      return;\n    }\n    runtime.runFork(data.prefetch(definition, input));\n  }, [data, definition, input, options.enabled, runtime]);\n\n  const refetch = useCallback(\n    () => runtime.runPromise(data.fetch(definition, input, { ...options.run, forceRefresh: true })),\n    [data, definition, input, options.run, runtime],\n  );\n\n  const invalidate = useCallback(\n    () => runtime.runPromise(data.invalidate(definition, input)),\n    [data, definition, input, runtime],\n  );\n\n  return {\n    ...snapshot,\n    refetch,\n    invalidate,\n  };\n};\n\nexport const useSuspenseQuery = <Name extends string, Input, Output, E>(\n  definition: QueryDefinition<Name, Input, Output, E>,\n  input: unknown,\n): Output => {\n  const result = useQuery(definition, input);\n  if (result.phase === \"failure\") {\n    throw result.error;\n  }\n  if (result.phase === \"success\") {\n    return result.data as Output;\n  }\n  throw result.refetch();\n};\n","import type { ManagedRuntime } from \"effect\";\nimport { createContext, useContext, useEffect, type ReactNode } from \"react\";\nimport type { AppServices } from \"../kernel/app\";\n\nexport type EffectReactManagedRuntime<R = AppServices> = ManagedRuntime.ManagedRuntime<R, never>;\n\nconst RuntimeContext = createContext<EffectReactManagedRuntime | null>(null);\n\nexport interface EffectProviderProps {\n  readonly runtime: EffectReactManagedRuntime;\n  readonly children?: ReactNode;\n}\n\nexport const EffectProvider = ({ runtime, children }: EffectProviderProps) => {\n  useEffect(\n    () => () => {\n      void runtime.dispose();\n    },\n    [runtime],\n  );\n\n  return <RuntimeContext.Provider value={runtime}>{children}</RuntimeContext.Provider>;\n};\n\nexport const useEffectRuntime = (): EffectReactManagedRuntime => {\n  const runtime = useContext(RuntimeContext);\n  if (runtime === null) {\n    throw new Error(\"Effect runtime is not available. Wrap your app with <EffectProvider>.\");\n  }\n  return runtime;\n};\n","import { Effect } from \"effect\";\nimport { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\nimport {\n  useQuery as useDataQuery,\n  useSuspenseQuery as useDataSuspenseQuery,\n  type UseQueryOptions,\n} from \"../data\";\nimport { Data } from \"../data\";\nimport { useEffectRuntime } from \"../react/provider\";\nimport type {\n  QueryDefinition,\n  QueryError,\n  QueryPhase,\n  QueryRunOptions,\n} from \"./types\";\n\ninterface InfiniteQueryEntry<Output, PageParam> {\n  readonly key: string;\n  readonly pageParam: PageParam;\n  readonly data: Output;\n}\n\nconst upsertInfiniteEntry = <Output, PageParam>(\n  entries: readonly InfiniteQueryEntry<Output, PageParam>[],\n  nextEntry: InfiniteQueryEntry<Output, PageParam>,\n): readonly InfiniteQueryEntry<Output, PageParam>[] => {\n  const index = entries.findIndex((entry) => entry.key === nextEntry.key);\n  if (index < 0) {\n    return [...entries, nextEntry];\n  }\n  const next = [...entries];\n  next[index] = nextEntry;\n  return next;\n};\n\nconst useDataService = () => {\n  const runtime = useEffectRuntime();\n  return useMemo(() => runtime.runSync(Data), [runtime]);\n};\n\nexport { type UseQueryOptions };\n\nexport const useQuery = <Name extends string, Input, Output, E>(\n  definition: QueryDefinition<Name, Input, Output, E>,\n  input: unknown,\n  options: UseQueryOptions = {},\n) => useDataQuery(definition, input, options);\n\nexport const useSuspenseQuery = <Name extends string, Input, Output, E>(\n  definition: QueryDefinition<Name, Input, Output, E>,\n  input: unknown,\n): Output => useDataSuspenseQuery(definition, input);\n\nexport interface UseInfiniteQueryOptions<Input, Output, PageParam> {\n  readonly initialPageParam: PageParam;\n  readonly getInput: (pageParam: PageParam) => Input;\n  readonly getNextPageParam: (\n    lastPage: Output,\n    allPages: readonly Output[],\n    lastPageParam: PageParam,\n    allPageParams: readonly PageParam[],\n  ) => PageParam | undefined;\n  readonly enabled?: boolean;\n  readonly run?: QueryRunOptions;\n}\n\nexport interface UseInfiniteQueryResult<Output, E, PageParam> {\n  readonly phase: QueryPhase;\n  readonly pages: readonly Output[];\n  readonly pageParams: readonly PageParam[];\n  readonly error: QueryError<E> | undefined;\n  readonly hasNextPage: boolean;\n  readonly isFetchingNextPage: boolean;\n  readonly fetchNextPage: () => Promise<Output | undefined>;\n  readonly refetch: () => Promise<readonly Output[]>;\n  readonly invalidate: () => Promise<void>;\n}\n\nexport const useInfiniteQuery = <Name extends string, Input, Output, E, PageParam>(\n  definition: QueryDefinition<Name, Input, Output, E>,\n  options: UseInfiniteQueryOptions<Input, Output, PageParam>,\n): UseInfiniteQueryResult<Output, E, PageParam> => {\n  const optionsRef = useRef(options);\n  optionsRef.current = options;\n\n  const initialPageParam = options.initialPageParam;\n  const enabled = options.enabled;\n  const run = options.run;\n\n  const getInput = useCallback(\n    (pageParam: PageParam): Input => optionsRef.current.getInput(pageParam),\n    [],\n  );\n\n  const getNextPageParam = useCallback(\n    (\n      lastPage: Output,\n      allPages: readonly Output[],\n      lastPageParam: PageParam,\n      allPageParams: readonly PageParam[],\n    ): PageParam | undefined =>\n      optionsRef.current.getNextPageParam(lastPage, allPages, lastPageParam, allPageParams),\n    [],\n  );\n\n  const runtime = useEffectRuntime();\n  const data = useDataService();\n  const [initialInput, setInitialInput] = useState<Input>(() =>\n    getInput(initialPageParam),\n  );\n  const [entries, setEntries] = useState<readonly InfiniteQueryEntry<Output, PageParam>[]>([]);\n  const [error, setError] = useState<QueryError<E> | undefined>(undefined);\n  const [isFetchingNextPage, setIsFetchingNextPage] = useState(false);\n\n  const initialQuery = useQuery(\n    definition,\n    initialInput,\n    {\n      ...(enabled !== undefined ? { enabled } : {}),\n      ...(run !== undefined ? { run } : {}),\n    },\n  );\n\n  useEffect(() => {\n    setInitialInput(getInput(initialPageParam));\n    setEntries([]);\n    setError(undefined);\n    setIsFetchingNextPage(false);\n  }, [definition, getInput, initialPageParam]);\n\n  useEffect(() => {\n    if (initialQuery.phase === \"success\") {\n      setEntries((current) =>\n        upsertInfiniteEntry(current, {\n          key: initialQuery.key,\n          pageParam: initialPageParam,\n          data: initialQuery.data as Output,\n        }),\n      );\n      setError(undefined);\n      return;\n    }\n    if (initialQuery.phase === \"failure\") {\n      setError(initialQuery.error as QueryError<E>);\n    }\n  }, [\n    initialQuery.data,\n    initialQuery.error,\n    initialQuery.key,\n    initialQuery.phase,\n    initialPageParam,\n  ]);\n\n  const pages = useMemo(() => entries.map((entry) => entry.data), [entries]);\n  const pageParams = useMemo(() => entries.map((entry) => entry.pageParam), [entries]);\n\n  const resolveNextPageParam = useCallback((): PageParam | undefined => {\n    const lastEntry = entries[entries.length - 1];\n    if (lastEntry !== undefined) {\n      return getNextPageParam(lastEntry.data, pages, lastEntry.pageParam, pageParams);\n    }\n    if (initialQuery.phase !== \"success\") {\n      return undefined;\n    }\n    const initialPage = initialQuery.data as Output;\n    return getNextPageParam(\n      initialPage,\n      [initialPage],\n      initialPageParam,\n      [initialPageParam],\n    );\n  }, [\n    entries,\n    getNextPageParam,\n    initialPageParam,\n    initialQuery.data,\n    initialQuery.phase,\n    pageParams,\n    pages,\n  ]);\n\n  const fetchNextPage = useCallback((): Promise<Output | undefined> => {\n    const nextPageParam = resolveNextPageParam();\n    if (nextPageParam === undefined) {\n      return runtime.runPromise(Effect.succeed<Output | undefined>(undefined));\n    }\n\n    setIsFetchingNextPage(true);\n    setError(undefined);\n\n    const input = getInput(nextPageParam);\n    const program = Effect.gen(function* () {\n      const value = yield* data.fetch(definition, input, run);\n      const snapshot = yield* data.getSnapshot(definition, input);\n      return {\n        key: snapshot.key,\n        pageParam: nextPageParam,\n        value,\n      };\n    });\n\n    return runtime.runPromise(program).then(\n      ({ key, pageParam, value }) => {\n        setEntries((current) =>\n          upsertInfiniteEntry(current, {\n            key,\n            pageParam,\n            data: value,\n          }),\n        );\n        setIsFetchingNextPage(false);\n        return value;\n      },\n      (cause: unknown) => {\n        setIsFetchingNextPage(false);\n        const resolved = cause as QueryError<E>;\n        setError(resolved);\n        return runtime.runPromise(Effect.fail(resolved));\n      },\n    );\n  }, [data, definition, getInput, resolveNextPageParam, run, runtime]);\n\n  const refetch = useCallback((): Promise<readonly Output[]> => {\n    const targets = pageParams.length === 0\n      ? [initialPageParam]\n      : pageParams;\n\n    setError(undefined);\n\n    const program = Effect.forEach(\n      targets,\n      (pageParam) => {\n        const input = getInput(pageParam);\n        return Effect.gen(function* () {\n          const value = yield* data.fetch(definition, input, {\n            ...run,\n            forceRefresh: true,\n          });\n          const snapshot = yield* data.getSnapshot(definition, input);\n          return {\n            key: snapshot.key,\n            pageParam,\n            data: value,\n          } satisfies InfiniteQueryEntry<Output, PageParam>;\n        });\n      },\n      {\n        concurrency: 1,\n        discard: false,\n      },\n    );\n\n    return runtime.runPromise(program).then(\n      (fetchedEntries) => {\n        setEntries(fetchedEntries);\n        return fetchedEntries.map((entry) => entry.data);\n      },\n      (cause: unknown) => {\n        const resolved = cause as QueryError<E>;\n        setError(resolved);\n        return runtime.runPromise(Effect.fail(resolved));\n      },\n    );\n  }, [data, definition, getInput, initialPageParam, pageParams, run, runtime]);\n\n  const invalidate = useCallback((): Promise<void> => {\n    const targets = pageParams.length === 0\n      ? [initialPageParam]\n      : pageParams;\n\n    const program = Effect.forEach(\n      targets,\n      (pageParam) => data.invalidate(definition, getInput(pageParam)),\n      {\n        concurrency: 1,\n        discard: true,\n      },\n    );\n\n    return runtime.runPromise(program).then(\n      () => {\n        setEntries([]);\n        setError(undefined);\n        setIsFetchingNextPage(false);\n        return undefined;\n      },\n      (cause: unknown) => {\n        const resolved = cause as QueryError<E>;\n        setError(resolved);\n        return runtime.runPromise(Effect.fail(resolved));\n      },\n    );\n  }, [data, definition, getInput, initialPageParam, pageParams, runtime]);\n\n  const resolvedError = error ??\n    (initialQuery.phase === \"failure\" ? (initialQuery.error as QueryError<E>) : undefined);\n\n  const phase: QueryPhase = resolvedError !== undefined\n    ? \"failure\"\n    : entries.length > 0\n      ? \"success\"\n      : initialQuery.phase;\n\n  return {\n    phase,\n    pages,\n    pageParams,\n    error: resolvedError,\n    hasNextPage: resolveNextPageParam() !== undefined,\n    isFetchingNextPage,\n    fetchNextPage,\n    refetch,\n    invalidate,\n  };\n};\n"],"mappings":"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","names":["fetchQuery","useQuery","useSuspenseQuery","import_effect","import_effect","import_react","invalidate","fetchQuery","import_effect","import_react","useDataService","useQuery","useSuspenseQuery","useDataService","invalidate"]}

package/dist/query/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./service";
+export * from "./react";

package/dist/query/index.js

@@ -0,0 +1,30 @@
+import {
+  fetchQuery,
+  invalidate,
+  invalidateQuery,
+  prefetch,
+  prefetchQuery,
+  useInfiniteQuery,
+  useQuery,
+  useSuspenseQuery
+} from "../chunk-H7MOLKTU.js";
+import "../chunk-2GIUCKL2.js";
+import {
+  QueryRuntimeError,
+  defineQuery
+} from "../chunk-C5JI7D7W.js";
+import "../chunk-YG22YP5K.js";
+import "../chunk-SKC3HMF3.js";
+export {
+  QueryRuntimeError,
+  defineQuery,
+  fetchQuery,
+  invalidate,
+  invalidateQuery,
+  prefetch,
+  prefetchQuery,
+  useInfiniteQuery,
+  useQuery,
+  useSuspenseQuery
+};
+//# sourceMappingURL=index.js.map

package/dist/query/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/query/react.d.ts

@@ -0,0 +1,27 @@
+import { type UseQueryOptions } from "../data";
+import type { QueryDefinition, QueryError, QueryPhase, QueryRunOptions } from "./types";
+export { type UseQueryOptions };
+export declare const useQuery: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown, options?: UseQueryOptions) => import("./types").QuerySnapshot<Output, E> & {
+    readonly refetch: () => Promise<Output>;
+    readonly invalidate: () => Promise<void>;
+};
+export declare const useSuspenseQuery: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown) => Output;
+export interface UseInfiniteQueryOptions<Input, Output, PageParam> {
+    readonly initialPageParam: PageParam;
+    readonly getInput: (pageParam: PageParam) => Input;
+    readonly getNextPageParam: (lastPage: Output, allPages: readonly Output[], lastPageParam: PageParam, allPageParams: readonly PageParam[]) => PageParam | undefined;
+    readonly enabled?: boolean;
+    readonly run?: QueryRunOptions;
+}
+export interface UseInfiniteQueryResult<Output, E, PageParam> {
+    readonly phase: QueryPhase;
+    readonly pages: readonly Output[];
+    readonly pageParams: readonly PageParam[];
+    readonly error: QueryError<E> | undefined;
+    readonly hasNextPage: boolean;
+    readonly isFetchingNextPage: boolean;
+    readonly fetchNextPage: () => Promise<Output | undefined>;
+    readonly refetch: () => Promise<readonly Output[]>;
+    readonly invalidate: () => Promise<void>;
+}
+export declare const useInfiniteQuery: <Name extends string, Input, Output, E, PageParam>(definition: QueryDefinition<Name, Input, Output, E>, options: UseInfiniteQueryOptions<Input, Output, PageParam>) => UseInfiniteQueryResult<Output, E, PageParam>;

package/dist/query/service.d.ts

@@ -0,0 +1,10 @@
+import { Effect } from "effect";
+import { Data } from "../data";
+import type { BoundaryDecodeError } from "../boundary";
+import type { BoundaryProtocolError } from "../boundary/errors";
+import type { QueryDefinition, QueryRuntimeError } from "./types";
+export declare const fetchQuery: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown, options?: import("./types").QueryRunOptions) => Effect.Effect<Output, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, Data>;
+export declare const prefetchQuery: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown) => Effect.Effect<void, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, Data>;
+export declare const invalidateQuery: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown) => Effect.Effect<void, QueryRuntimeError, Data>;
+export declare const prefetch: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown) => Effect.Effect<void, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, Data>;
+export declare const invalidate: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown) => Effect.Effect<void, QueryRuntimeError, Data>;

package/dist/query/types.d.ts

@@ -0,0 +1,5 @@
+import type { BoundaryDecodeError } from "../boundary";
+import type { BoundaryProtocolError } from "../boundary/errors";
+import type { QueryRuntimeError } from "../data/types";
+export { defineQuery, QueryRuntimeError, type QueryDefinition, type QueryPhase, type QuerySnapshot, type QueryRunOptions, type QueryRuntimeOptions, } from "../data/types";
+export type QueryError<E> = E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError;

package/dist/react/index.d.ts

@@ -0,0 +1 @@
+export * from "./provider";

package/dist/react/provider.d.ts

@@ -0,0 +1,10 @@
+import type { ManagedRuntime } from "effect";
+import { type ReactNode } from "react";
+import type { AppServices } from "../kernel/app";
+export type EffectReactManagedRuntime<R = AppServices> = ManagedRuntime.ManagedRuntime<R, never>;
+export interface EffectProviderProps {
+    readonly runtime: EffectReactManagedRuntime;
+    readonly children?: ReactNode;
+}
+export declare const EffectProvider: ({ runtime, children }: EffectProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useEffectRuntime: () => EffectReactManagedRuntime;

package/dist/realtime/channel.d.ts

@@ -0,0 +1,15 @@
+import { Effect, Stream } from "effect";
+export interface CreateChannelOptions {
+    readonly replay?: number;
+}
+export interface RealtimeChannel<Message> {
+    readonly publish: (message: Message) => Effect.Effect<void>;
+    readonly publishAll: (messages: Iterable<Message>) => Effect.Effect<void>;
+    readonly subscribe: () => Stream.Stream<Message>;
+    readonly stream: Stream.Stream<Message>;
+    readonly shutdown: Effect.Effect<void>;
+}
+export declare const createChannel: <Message>(options?: CreateChannelOptions) => Effect.Effect<RealtimeChannel<Message>>;
+export declare const publish: <Message>(channel: RealtimeChannel<Message>, message: Message) => Effect.Effect<void>;
+export declare const publishAll: <Message>(channel: RealtimeChannel<Message>, messages: Iterable<Message>) => Effect.Effect<void>;
+export declare const subscribe: <Message>(channel: RealtimeChannel<Message>) => Stream.Stream<Message>;