@evolu/common 8.0.0-next.5 → 8.0.0

package/dist/src/Function.js

@@ -3,6 +3,8 @@
  *
  * @module
  */
+import { assertNotDisposed } from "./Assert.js";
+import { isFunction } from "./Object.js";
 /**
  * Helper function to ensure exhaustive matching in a switch statement. Throws
  * an error if an unhandled case is encountered.
@@ -10,32 +12,36 @@
  * ### Example
  *
  * ```ts
+ * import { exhaustiveCheck } from "@evolu/common";
+ *
  * type Color = "red" | "green" | "blue";
+ * const handled: Array<string> = [];
  *
  * const handleColor = (color: Color): void => {
  *   switch (color) {
  *     case "red":
- *       console.log("Handling red");
+ *       handled.push("Handling red");
  *       break;
  *     case "green":
- *       console.log("Handling green");
+ *       handled.push("Handling green");
  *       break;
  *     case "blue":
- *       console.log("Handling blue");
+ *       handled.push("Handling blue");
  *       break;
  *     default:
- *       exhaustiveCheck(color); // Ensures all cases are handled
+ *       exhaustiveCheck(color);
  *   }
  * };
+ *
+ * handleColor("blue");
+ * expect(handled).toEqual(["Handling blue"]);
  * ```
  *
  * Use this primarily in side-effect switches (`void` branches). For
  * value-producing switches, TypeScript can enforce exhaustiveness without a
- * `default` branch.
- *
- * ### Example
+ * `default` branch in either of the following styles.
  *
- * Return from each case for value-producing switches.
+ * ### Return from every case
  *
  * ```ts
  * type Color = "red" | "green" | "blue";
@@ -50,11 +56,11 @@
  *       return "#0000ff";
  *   }
  * };
- * ```
  *
- * ### Example
+ * expect(colorToHex("green")).toBe("#00ff00");
+ * ```
  *
- * Use assignment + no `default` to get exhaustiveness by definite assignment.
+ * ### Assign in every case
  *
  * ```ts
  * type Input =
@@ -62,7 +68,7 @@
  *   | { readonly type: "Query" }
  *   | { readonly type: "Export" };
  *
- * const onInput = (input: Input): void => {
+ * const inputToKind = (input: Input): "A" | "B" | "C" => {
  *   let result: "A" | "B" | "C";
  *
  *   switch (input.type) {
@@ -77,12 +83,10 @@
  *       break;
  *   }
  *
- *   handleKind(result);
+ *   return result;
  * };
  *
- * const handleKind = (kind: "A" | "B" | "C"): void => {
- *   console.log(kind);
- * };
+ * expect(inputToKind({ type: "Query" })).toBe("B");
  * ```
  */
 export const exhaustiveCheck = (value) => {
@@ -97,41 +101,78 @@ export const exhaustiveCheck = (value) => {
  * ### Example
  *
  * ```ts
- * const values = [1, 2, 3];
- * const same = values.map(identity); // [1, 2, 3]
+ * import { identity } from "@evolu/common";
  *
+ * const values = [1, 2, 3];
+ * const object = { value: 1 };
  * const getTransform = (shouldDouble: boolean) =>
- *   shouldDouble ? (x: number) => x * 2 : identity;
+ *   shouldDouble ? (value: number) => value * 2 : identity;
+ *
+ * expect(values.map(identity)).toEqual([1, 2, 3]);
+ * expect(identity(object)).toBe(object);
+ * expect(getTransform(false)(2)).toBe(2);
  * ```
  */
 export const identity = (a) => a;
+export function disposable(value, disposer = null) {
+    const mutableValue = value;
+    const ownedDisposer = disposer?.move() ?? new DisposableStack();
+    for (const [key, property] of Object.entries(value)) {
+        if (!isFunction(property))
+            continue;
+        mutableValue[key] = (...args) => {
+            assertNotDisposed(ownedDisposer);
+            return property(...args);
+        };
+    }
+    if (ownedDisposer instanceof AsyncDisposableStack) {
+        value[Symbol.asyncDispose] = () => ownedDisposer.disposeAsync();
+    }
+    else {
+        value[Symbol.dispose] = () => ownedDisposer.dispose();
+    }
+    return value;
+}
+export const isDisposable = (value) => {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return (isFunction(value[Symbol.dispose]) ||
+        isFunction(value[Symbol.asyncDispose]));
+};
 /**
- * Creates a {@link Lazy} from a precomputed value.
+ * Creates a {@link Thunk} that always returns a precomputed value.
  *
- * Use when the value is expensive to compute and want to compute it once at
+ * Use when the value is expensive to compute and you want to compute it once at
  * definition time rather than on every call.
  *
  * ### Example
  *
  * ```ts
- * // Computed once at definition, returned on every call
- * const getConfig = lazy(parseConfig(rawConfig));
+ * import { constant } from "@evolu/common";
+ *
+ * let version = 0;
+ * const readConfig = () => ({ version: ++version });
+ * const getConstantConfig = constant(readConfig());
+ * const getFreshConfig = () => readConfig();
  *
- * // vs. computed on every call
- * const getConfig = () => parseConfig(rawConfig);
+ * expect(getConstantConfig()).toBe(getConstantConfig());
+ * expect(getConstantConfig().version).toBe(1);
+ * expect(getFreshConfig().version).toBe(2);
+ * expect(getFreshConfig().version).toBe(3);
  * ```
  */
-export const lazy = (value) => () => value;
-/** A {@link Lazy} that returns `true`. */
-export const lazyTrue = /*#__PURE__*/ lazy(true);
-/** A {@link Lazy} that returns `false`. */
-export const lazyFalse = /*#__PURE__*/ lazy(false);
-/** A {@link Lazy} that returns `null`. */
-export const lazyNull = /*#__PURE__*/ lazy(null);
-/** A {@link Lazy} that returns `undefined`. */
-export const lazyUndefined = /*#__PURE__*/ lazy(undefined);
-/** A {@link Lazy} that returns `undefined` for void callbacks. */
-export const lazyVoid = lazyUndefined;
+export const constant = (value) => () => value;
+/** A {@link Thunk} that returns `true`. */
+export const constTrue = /*#__PURE__*/ constant(true);
+/** A {@link Thunk} that returns `false`. */
+export const constFalse = /*#__PURE__*/ constant(false);
+/** A {@link Thunk} that returns `null`. */
+export const constNull = /*#__PURE__*/ constant(null);
+/** A {@link Thunk} that returns `undefined`. */
+export const constUndefined = 
+/*#__PURE__*/ constant(undefined);
+/** A {@link Thunk} that returns `undefined` for void callbacks. */
+export const constVoid = constUndefined;
 /**
  * Development placeholder that always throws.
  *
@@ -142,17 +183,19 @@ export const lazyVoid = lazyUndefined;
  * ### Example
  *
  * ```ts
- * // Type inferred from return type annotation
- * const fetchUser = (id: UserId): Result<User, FetchError> => todo();
+ * import { todo } from "@evolu/common";
  *
- * expectTypeOf(fetchUser).returns.toEqualTypeOf<
- *   Result<User, FetchError>
- * >();
+ * interface Config {
+ *   readonly theme: string;
+ * }
  *
- * // Explicit generic when no return type
+ * const getCount = (): number => todo();
  * const getConfig = () => todo<Config>();
  *
- * expectTypeOf(getConfig).returns.toEqualTypeOf<Config>();
+ * expectTypeOf<
+ *   [ReturnType<typeof getCount>, ReturnType<typeof getConfig>]
+ * >().toEqualTypeOf<[number, Config]>();
+ * expect(getCount).toThrow("not yet implemented");
  * ```
  */
 // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters

package/dist/src/Http.d.ts

@@ -0,0 +1,394 @@
+/**
+ * Task-aware HTTP helpers.
+ *
+ * @module
+ */
+import { type Result } from "./Result.ts";
+import type { Task } from "./Task.ts";
+import type { Typed } from "./Type.ts";
+import type { Awaitable } from "./Types.ts";
+/**
+ * WHATWG-fetch-compatible function used by {@link fetch}.
+ *
+ * A default dependency, replaceable at the composition root — for a
+ * platform-optimized fetch such as React Native's, a configured undici
+ * instance, or a test double. Implementations must be pre-bound; unbound
+ * `globalThis.fetch` throws in browsers.
+ *
+ * @group Fetch
+ */
+export type NativeFetch = typeof globalThis.fetch;
+/**
+ * Dependency wrapper for {@link NativeFetch}.
+ *
+ * @group Fetch
+ */
+export interface NativeFetchDep {
+    readonly nativeFetch: NativeFetch;
+}
+/**
+ * Body mode for {@link fetch}.
+ *
+ * A mode selects a built-in consumer that reads the {@link Response} inside the
+ * fetch Task:
+ *
+ * - `"bytes"` — reads the body as a `Uint8Array<ArrayBuffer>`.
+ * - `"headers"` — cancels the body and returns {@link FetchResponse}. Pair it with
+ *   `{ method: "HEAD" }` when the server should not send a body.
+ * - `"json"` — parses the body as JSON and returns `unknown`. Narrow or decode at
+ *   the call site; there is deliberately no generic to cast through.
+ * - `"text"` — reads the body as a string.
+ *
+ * Body modes (`"bytes"`, `"json"`, `"text"`) return {@link FetchStatusError} for
+ * non-2xx responses. `"headers"` does not judge status, because the status is
+ * usually the value being asked for.
+ *
+ * @group Fetch
+ */
+export type FetchMode = "text" | "json" | "bytes" | "headers";
+/**
+ * Body-free {@link Response} view safe to return from {@link fetch}.
+ *
+ * {@link fetch} returns this view only after the native body has been drained,
+ * errored, or cancelled, so none of its usable members depends on the request
+ * signal. Body-reading members and `Response.clone` are omitted because they
+ * would be invalid after the fetch Task settles.
+ *
+ * This is a TypeScript contract, not a runtime security boundary: the runtime
+ * value can still be a native Response, and casts can access omitted members.
+ *
+ * @group Fetch
+ */
+export type FetchResponse = Omit<Response, "arrayBuffer" | "blob" | "body" | "bodyUsed" | "bytes" | "clone" | "formData" | "json" | "text">;
+/**
+ * Error returned by {@link fetch} body modes.
+ *
+ * The union distinguishes native request failures, non-2xx responses, and body
+ * read failures. Narrow on `type` when handling a specific case. The
+ * distinction matters for retries: {@link FetchBodyError} means a 2xx response
+ * failed during reading, so the server may have committed the request.
+ *
+ * @group Fetch
+ */
+export type FetchError = FetchTransportError | FetchStatusError | FetchBodyError;
+/**
+ * Error returned when the native fetch request fails before a response exists.
+ *
+ * @group Fetch
+ */
+export interface FetchTransportError extends Typed<"FetchTransportError"> {
+    readonly error: unknown;
+}
+/**
+ * Error returned when a body mode receives a non-2xx response.
+ *
+ * The response body is drained as text before this error is returned. Draining
+ * buffers the whole error body; error responses are expected to be small. If
+ * the drain itself fails, `body` contains the read error.
+ *
+ * @group Fetch
+ */
+export interface FetchStatusError extends Typed<"FetchStatusError"> {
+    readonly response: FetchResponse;
+    readonly body: Result<string, unknown>;
+}
+/**
+ * Error returned when a body mode cannot read or decode a 2xx response.
+ *
+ * This includes mid-stream network failures, decoding failures, and — for the
+ * `"json"` mode — empty bodies such as 204 responses, which are not JSON. Do
+ * not use `"json"` for endpoints that return no content.
+ *
+ * @group Fetch
+ */
+export interface FetchBodyError extends Typed<"FetchBodyError"> {
+    readonly response: FetchResponse;
+    readonly error: unknown;
+}
+/**
+ * Consumes a native {@link Response} before {@link fetch} settles.
+ *
+ * The callback runs inside the fetch Task, while the request signal is still
+ * alive. Return a Result error for expected domain failures. Throwing or
+ * rejecting with a non-abort error is a defect, like any other Task body.
+ *
+ * Consumers take values, not dependencies; close over anything they need. A
+ * consumer that needs its own timeout, retries, or child Tasks has outgrown
+ * being a consumer: fetch the body with a mode and compose Tasks on the plain
+ * value, or write a Task that owns the whole request.
+ *
+ * Consumers do not have to normalize abort. {@link fetch} rethrows Evolu
+ * {@link AbortError}, normalizes host abort errors after the Run aborts, and
+ * treats an Err returned after abort as abort control flow — so a consumer's
+ * `try`/`catch` around a body read cannot accidentally turn an abort into a
+ * domain error. An Ok returned after abort is kept; only errors are presumed to
+ * be abort in disguise.
+ *
+ * The Response and anything derived from its live body, such as a reader, must
+ * not escape the consumer. Consume to plain values before returning.
+ *
+ * @group Fetch
+ */
+export type FetchConsume<T, E = never> = (response: Response) => Awaitable<Result<T, E>>;
+/**
+ * Fetches a resource and consumes the {@link Response} inside the Task, so the
+ * body is read while the request signal is still alive.
+ *
+ * The request runs through {@link NativeFetchDep | run.deps.nativeFetch}.
+ * Because native fetch is a default dependency, platforms and tests can replace
+ * it without changing call sites.
+ *
+ * With a {@link FetchMode}, non-2xx responses return {@link FetchStatusError}
+ * (except `"headers"`, which reports status as a value) and unreadable bodies
+ * return {@link FetchBodyError}. With a {@link FetchConsume} callback, native
+ * status semantics apply: HTTP error statuses resolve, and the consumer decides
+ * how to interpret the status and body.
+ *
+ * `signal` is not accepted in init because abort is controlled by the current
+ * Run.
+ *
+ * Aborting the Run aborts the underlying request, any response that arrives
+ * after abort, and any in-progress body read. Abort is represented as
+ * {@link AbortError}, not FetchError: `run(fetch(...))` rejects with AbortError,
+ * and `run.abortable(fetch(...))` returns it as an {@link Err}.
+ *
+ * Some runtimes reject aborted fetches with their own error instead of
+ * `signal.reason`. This wrapper normalizes abort rejections from native fetch,
+ * built-in body reads, and consumer callbacks back to the Run's AbortError.
+ *
+ * `fetch` owns request lifetime and Response containment. It does not transform
+ * requests or interpret app protocols beyond the built-in modes. Use Task
+ * helpers for resilience, app helpers for app conventions, a replacement
+ * {@link NativeFetch} for request-wide behavior (base URLs, auth, logging), and
+ * consumers for response interpretation.
+ *
+ * ### Composing fetch
+ *
+ * Resilience is ordinary Task composition: wrap `fetch(url, "json")` in
+ * {@link timeout}, then in {@link retry}.
+ *
+ * ```ts
+ * import {
+ *   createRun,
+ *   exponential,
+ *   fetch,
+ *   retry,
+ *   take,
+ *   timeout,
+ *   type NativeFetch,
+ * } from "@evolu/common";
+ *
+ * const fetchWithRetry = (url: string) =>
+ *   retry(
+ *     timeout(fetch(url, "json"), "30s"),
+ *     take(2)(exponential("100ms")),
+ *   );
+ *
+ * let requestCount = 0;
+ * const nativeFetch: NativeFetch = () => {
+ *   requestCount++;
+ *   return Promise.resolve(
+ *     requestCount === 1
+ *       ? new Response("Try again", { status: 503 })
+ *       : new Response('{"name":"Ada"}'),
+ *   );
+ * };
+ * await using run = createRun({ nativeFetch });
+ *
+ * expectOk(await run(fetchWithRetry("/api/user")), { name: "Ada" });
+ * ```
+ *
+ * App conventions belong in small app-owned helpers. For example, posting JSON
+ * is native `init` plus two conventions worth centralizing — the content-type
+ * header and the stringify:
+ *
+ * ```ts
+ * import {
+ *   createRun,
+ *   fetch,
+ *   type FetchError,
+ *   type NativeFetch,
+ *   type Task,
+ * } from "@evolu/common";
+ *
+ * const postJson = (
+ *   url: string,
+ *   data: unknown,
+ * ): Task<unknown, FetchError> =>
+ *   fetch(url, "json", {
+ *     method: "POST",
+ *     headers: { "content-type": "application/json" },
+ *     body: JSON.stringify(data),
+ *   });
+ *
+ * const nativeFetch: NativeFetch = () =>
+ *   Promise.resolve(new Response('{"id":"user-1"}'));
+ * await using run = createRun({ nativeFetch });
+ *
+ * expectOk(await run(postJson("/api/users", { name: "Ada" })), {
+ *   id: "user-1",
+ * });
+ * ```
+ *
+ * Your app's version will grow your conventions — auth, envelopes, error
+ * mapping — which is why it belongs to the app, not to `fetch`.
+ *
+ * ### Intercepting requests
+ *
+ * Request-wide behavior belongs to a replacement {@link NativeFetch} installed
+ * at the composition root. This is the equivalent of interceptors or hooks in
+ * libraries that expose client instances.
+ *
+ * ```ts
+ * import { createRun, fetch, type NativeFetch } from "@evolu/common";
+ *
+ * const token = "secret-token";
+ * const baseUrl = "https://api.example.com/v1/";
+ * let interceptedRequest: Request | undefined;
+ * const baseFetch: NativeFetch = (input, init) => {
+ *   interceptedRequest = new Request(input, init);
+ *   return Promise.resolve(new Response("ok"));
+ * };
+ *
+ * const nativeFetch: NativeFetch = (input, init) => {
+ *   const headers = new Headers(init?.headers);
+ *   headers.set("authorization", `Bearer ${token}`);
+ *
+ *   // Only string inputs are resolved against the base URL; URL and Request
+ *   // inputs are passed through unchanged.
+ *   const url =
+ *     typeof input === "string" ? new URL(input, baseUrl) : input;
+ *   return baseFetch(url, { ...init, headers });
+ * };
+ *
+ * await using run = createRun({ nativeFetch });
+ * expectOk(await run(fetch("users", "text")), "ok");
+ * expect({
+ *   url: interceptedRequest?.url,
+ *   authorization: interceptedRequest?.headers.get("authorization"),
+ * }).toEqual({
+ *   url: "https://api.example.com/v1/users",
+ *   authorization: "Bearer secret-token",
+ * });
+ * ```
+ *
+ * ### Consuming responses
+ *
+ * Built-in modes handle common bodies. Specialized response interpretation
+ * belongs in a consumer. Typed decoders, response envelopes, streaming, and
+ * custom status semantics can be built on top without changing `fetch`.
+ *
+ * ```ts
+ * import {
+ *   createRun,
+ *   fetch,
+ *   ok,
+ *   type FetchTransportError,
+ *   type NativeFetch,
+ *   type Task,
+ * } from "@evolu/common";
+ *
+ * const nativeFetch: NativeFetch = (input) =>
+ *   Promise.resolve(
+ *     String(input).endsWith("/metadata")
+ *       ? new Response(null, {
+ *           status: 204,
+ *           headers: { "cache-control": "max-age=60" },
+ *         })
+ *       : new Response('{"name":"Ada"}'),
+ *   );
+ * await using run = createRun({ nativeFetch });
+ *
+ * const user = await run(fetch("/api/user", "json"));
+ * const metadata = fetch("/api/user/metadata", (response) =>
+ *   ok({
+ *     status: response.status,
+ *     cache: response.headers.get("cache-control"),
+ *   }),
+ * );
+ * expectTypeOf(metadata).toEqualTypeOf<
+ *   Task<{ status: number; cache: string | null }, FetchTransportError>
+ * >();
+ * expectOk(user, { name: "Ada" });
+ * expectOk(await run(metadata), { status: 204, cache: "max-age=60" });
+ * ```
+ *
+ * ### Aborting fetch
+ *
+ * Abort follows the standard Task rules: a Fiber from `run(fetch(...))` rejects
+ * with {@link AbortError}, and `run.abortable(fetch(...))` returns it as a
+ * Result error.
+ *
+ * ```ts
+ * import {
+ *   AbortError,
+ *   createRun,
+ *   fetch,
+ *   type NativeFetch,
+ * } from "@evolu/common";
+ *
+ * const nativeFetch: NativeFetch = (_input, init) =>
+ *   new Promise<Response>((_resolve, reject) => {
+ *     const signal = init?.signal;
+ *     if (!signal) throw new Error("Missing signal");
+ *     signal.addEventListener("abort", () => reject(signal.reason), {
+ *       once: true,
+ *     });
+ *   });
+ * await using run = createRun({ nativeFetch });
+ *
+ * const fiber = run.abortable(fetch("/api/user", "json"));
+ * fiber.abort();
+ * const result = await fiber;
+ *
+ * expect(!result.ok && AbortError.is(result.error)).toBe(true);
+ * ```
+ *
+ * @group Fetch
+ */
+export declare function fetch(input: RequestInfo | URL, mode: "text", init?: Omit<RequestInit, "signal">): Task<string, FetchError>;
+export declare function fetch(input: RequestInfo | URL, mode: "json", init?: Omit<RequestInit, "signal">): Task<unknown, FetchError>;
+export declare function fetch(input: RequestInfo | URL, mode: "bytes", init?: Omit<RequestInit, "signal">): Task<Uint8Array<ArrayBuffer>, FetchError>;
+export declare function fetch(input: RequestInfo | URL, mode: "headers", init?: Omit<RequestInit, "signal">): Task<FetchResponse, FetchTransportError>;
+export declare function fetch<T, E = never>(input: RequestInfo | URL, consume: FetchConsume<T, E>, init?: Omit<RequestInit, "signal">): Task<T, FetchTransportError | E>;
+/**
+ * Test {@link NativeFetch} that records calls and serves queued handlers.
+ *
+ * Each call shifts the next handler. Calling with an empty queue throws, so a
+ * test never silently reaches an unplanned request.
+ *
+ * @group Testing
+ */
+export interface TestNativeFetch extends NativeFetch {
+    readonly calls: ReadonlyArray<TestNativeFetchCall>;
+    readonly handle: (handler: TestNativeFetchHandler) => void;
+}
+/**
+ * Recorded {@link TestNativeFetch} call.
+ *
+ * @group Testing
+ */
+export interface TestNativeFetchCall {
+    readonly input: RequestInfo | URL;
+    readonly init: RequestInit | undefined;
+}
+/**
+ * Handler for one {@link TestNativeFetch} call.
+ *
+ * @group Testing
+ */
+export type TestNativeFetchHandler = (input: RequestInfo | URL, init: RequestInit | undefined) => Awaitable<Response>;
+/**
+ * Creates {@link TestNativeFetch}.
+ *
+ * @group Testing
+ */
+export declare const testCreateNativeFetch: (...handlers: ReadonlyArray<TestNativeFetchHandler>) => TestNativeFetch;
+/**
+ * Creates a Response body for {@link NativeFetch} tests that errors on first
+ * read.
+ *
+ * @group Testing
+ */
+export declare const testCreateNativeFetchErroringBody: (error?: unknown) => ReadableStream<Uint8Array>;
+//# sourceMappingURL=Http.d.ts.map

package/dist/src/Http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Http.d.ts","sourceRoot":"","sources":["../../src/Http.ts"],"names":[],"mappings":"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"}