universal-api-layer 0.7.0

package/dist/chunk-YTM3FV65.js

@@ -0,0 +1,19 @@
+// src/core/errors.ts
+var ApiError = class extends Error {
+  constructor(message, status = 0, fieldErrors = {}, data, code = "http", cause) {
+    super(message, cause === void 0 ? void 0 : { cause });
+    this.status = status;
+    this.fieldErrors = fieldErrors;
+    this.data = data;
+    this.code = code;
+    this.name = "ApiError";
+  }
+  status;
+  fieldErrors;
+  data;
+  code;
+};
+
+export {
+  ApiError
+};

package/dist/cli/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+declare function templates(framework: string, language: string): Record<string, string>;
+
+export { templates };

package/dist/cli/index.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { readFile, writeFile, mkdir, access } from "fs/promises";
+import { resolve } from "path";
+import { createInterface } from "readline/promises";
+function templates(framework, language) {
+  if (framework === "angular") {
+    if (language !== "typescript")
+      throw new Error("Angular scaffolding requires TypeScript.");
+    return {
+      "src/api.providers.ts": `import {createApiClient} from 'universal-api-layer';
+import {provideApiClient} from 'universal-api-layer/angular';
+export const apiProviders=provideApiClient(()=>createApiClient({baseUrl:'/api'}));
+`,
+      "src/ApiExample.ts": `import {Component,DestroyRef,inject,signal} from '@angular/core';
+import {takeUntilDestroyed} from '@angular/core/rxjs-interop';
+import {ApiService} from 'universal-api-layer/angular';
+@Component({selector:'api-example',standalone:true,template:'<button (click)="load()">Load users</button><pre>{{ data() }}</pre><p role="alert">{{ error() }}</p>'})
+export class ApiExample {private api=inject(ApiService);private destroy=inject(DestroyRef);readonly data=signal('');readonly error=signal('');load(){this.api.request$('/users').pipe(takeUntilDestroyed(this.destroy)).subscribe({next:value=>this.data.set(JSON.stringify(value)),error:cause=>this.error.set(cause instanceof Error?cause.message:'Request failed')});}}
+`
+    };
+  }
+  const ts = language === "typescript";
+  const ext = ts ? "ts" : "js";
+  const setup = `import { createApiClient } from 'universal-api-layer';
+export const client = createApiClient({ baseUrl: '/api' });
+`;
+  const type = ts ? "<{ data: { id: number; name: string }[] }, { id: number; name: string }[]>" : "";
+  if (framework === "react")
+    return {
+      [`src/api.${ext}`]: setup,
+      [`src/ApiExample.${ts ? "tsx" : "jsx"}`]: `import { useApiQuery, useApiMutation } from 'universal-api-layer/react';
+export default function ApiExample() {
+  const users = useApiQuery${type}({ key: ['users'], url: '/users', select: response => response?.data ?? [] });
+  const create = useApiMutation({ url: '/users', invalidateKeys: [['users']] });
+  return <section><button onClick={() => create.mutate({ name: 'Bahaa' })}>Add user</button>{users.isPending ? <p>Loading...</p> : users.error ? <p>{users.error.message}</p> : <pre>{JSON.stringify(users.data)}</pre>}{create.error && <pre>{JSON.stringify(create.error.fieldErrors)}</pre>}</section>;
+}
+`
+    };
+  return {
+    [`src/api.${ext}`]: setup,
+    "src/ApiExample.vue": `<script setup${ts ? ' lang="ts"' : ""}>
+import { useApiQuery, useApiMutation } from 'universal-api-layer/vue';
+const { data, isPending, error } = useApiQuery${type}({ key: ['users'], url: '/users', select: response => response?.data ?? [] });
+const { mutate, error: mutationError } = useApiMutation({ url: '/users', invalidateKeys: [['users']] });
+</script>
+<template><section><button @click="mutate({ name: 'Bahaa' })">Add user</button><p v-if="isPending">Loading...</p><p v-else-if="error">{{ error.message }}</p><pre v-else>{{ data }}</pre><pre v-if="mutationError">{{ mutationError.fieldErrors }}</pre></section></template>
+`
+  };
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help")) {
+    console.log(
+      "universal-api-layer init [--framework react|vue|angular] [--language javascript|typescript] [--force]"
+    );
+    return;
+  }
+  if (args.shift() !== "init")
+    throw new Error(
+      "Use: universal-api-layer init --framework react|vue|angular --language javascript|typescript"
+    );
+  const flags = {};
+  let force = false;
+  while (args.length) {
+    const arg = args.shift();
+    if (arg === "--force") {
+      force = true;
+      continue;
+    }
+    if (!["--framework", "--language"].includes(arg) || !args[0] || args[0].startsWith("--"))
+      throw new Error(`Invalid option ${arg}. Use --help.`);
+    flags[arg.slice(2)] = args.shift();
+  }
+  if (flags.framework && !["react", "vue", "angular"].includes(flags.framework))
+    throw new Error("Expected --framework react|vue|angular.");
+  if (flags.language && !["javascript", "typescript"].includes(flags.language))
+    throw new Error("Expected --language javascript|typescript.");
+  let pkg = {};
+  try {
+    pkg = JSON.parse(await readFile("package.json", "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const frameworks = ["react", "vue", "angular"].filter(
+    (name) => deps[name === "angular" ? "@angular/core" : name]
+  );
+  const exists = async (name) => access(name).then(
+    () => true,
+    () => false
+  );
+  let framework = flags.framework ?? (frameworks.length === 1 ? frameworks[0] : void 0);
+  const hasTsConfig = await exists("tsconfig.json");
+  const hasJsConfig = await exists("jsconfig.json");
+  let language = flags.language ?? (hasTsConfig !== hasJsConfig ? hasTsConfig ? "typescript" : "javascript" : void 0);
+  if (framework === "angular") language = flags.language ?? "typescript";
+  if (!language && !(hasTsConfig && hasJsConfig)) {
+    const { readdir } = await import("fs/promises");
+    const ignored = /* @__PURE__ */ new Set([
+      "node_modules",
+      "dist",
+      "build",
+      "coverage",
+      ".git",
+      ".next",
+      ".nuxt",
+      ".output",
+      ".artifacts",
+      "tests",
+      "test"
+    ]);
+    async function sourceFiles(directory) {
+      const entries = await readdir(directory, { withFileTypes: true });
+      const children = await Promise.all(
+        entries.filter(
+          (entry) => !ignored.has(entry.name) && !entry.name.startsWith(".")
+        ).map(async (entry) => {
+          const name = resolve(directory, entry.name);
+          if (entry.isDirectory()) return sourceFiles(name);
+          return entry.isFile() && /\.(?:[cm]?[jt]sx?|vue)$/.test(entry.name) && !/\.(?:config|test|spec|d)\.[cm]?[jt]sx?$/.test(entry.name) ? [name] : [];
+        })
+      );
+      return children.flat();
+    }
+    const files2 = await sourceFiles(await exists("src") ? "src" : ".");
+    let ts = files2.some((f) => /\.(ts|tsx|mts|cts)$/.test(f));
+    let js = files2.some((f) => /\.(js|jsx|mjs|cjs)$/.test(f));
+    for (const name of files2.filter((f) => f.endsWith(".vue"))) {
+      const source = await readFile(name, "utf8");
+      if (/<script\b[^>]*\blang\s*=\s*['"]ts['"]/i.test(source)) ts = true;
+      else js = true;
+    }
+    if (ts !== js) language = ts ? "typescript" : "javascript";
+  }
+  async function choose(label, choices) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+      throw new Error(
+        `Cannot detect ${label}. Pass --${label} ${choices.join("|")} in non-interactive mode.`
+      );
+    const input = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    try {
+      return (await input.question(`${label} (${choices.join("/")}): `)).trim();
+    } finally {
+      input.close();
+    }
+  }
+  framework ??= await choose("framework", ["react", "vue", "angular"]);
+  if (framework === "angular") {
+    if (flags.language === "javascript")
+      throw new Error("Angular scaffolding requires TypeScript.");
+    language = "typescript";
+  }
+  language ??= await choose("language", ["javascript", "typescript"]);
+  if (!["react", "vue", "angular"].includes(framework) || !["javascript", "typescript"].includes(language))
+    throw new Error(
+      "Expected --framework react|vue|angular and --language javascript|typescript."
+    );
+  const files = templates(framework, language);
+  if (!force) {
+    for (const name of Object.keys(files))
+      if (await exists(name))
+        throw new Error(
+          `Refusing to overwrite ${name}. Use --force to replace generated files.`
+        );
+  }
+  for (const [name, content] of Object.entries(files)) {
+    await mkdir(resolve(name, ".."), { recursive: true });
+    await writeFile(name, content, { flag: force ? "w" : "wx" });
+  }
+  if (framework === "angular") {
+    console.log(
+      "Created Angular API providers and standalone example. Add apiProviders from './api.providers' to your application configuration providers, then import ApiExample into a standalone component."
+    );
+    console.log(
+      "Install: npm install universal-api-layer @angular/core rxjs@^7.8.2\nUse Angular 20.3-22 and its matching Angular/Node/TypeScript toolchain. No existing bootstrap files were changed."
+    );
+    return;
+  }
+  console.log(
+    `Created API setup and example.
+Install: npm install universal-api-layer ${framework === "react" ? "react@^19 react-dom@^19 @tanstack/react-query@^5" : "vue@^3.5 @tanstack/vue-query@^5"}`
+  );
+  console.log(
+    "Requires Node >=22.13 and npm >=11.21.1; install the listed optional peers explicitly."
+  );
+  console.log(
+    framework === "react" ? "Import { client } from './api'; import { ApiProvider } from 'universal-api-layer/react'; wrap <App /> with <ApiProvider client={client}>. ApiProvider installs QueryClientProvider; pass queryClient to reuse an existing instance." : "Import { client } from './api'; import { createApiPlugin } from 'universal-api-layer/vue'; call app.use(createApiPlugin({ client })) before app.mount()."
+  );
+  if (deps.next || deps.nuxt)
+    console.log(
+      "Next.js/Nuxt detected: only standalone API/example files were generated; register them manually. Next.js requires a client provider boundary; Nuxt requires a client plugin and a per-request client for SSR. Configure these manually."
+    );
+}
+main().catch((error) => {
+  console.error(error.message);
+  process.exitCode = 1;
+});
+export {
+  templates
+};

package/dist/client-ByBlZaRg.d.ts

@@ -0,0 +1,169 @@
+type FieldErrors = Record<string, string[]>;
+type ApiErrorCode = "backpressure" | "http" | "network" | "timeout" | "cancelled" | "auth" | "parse" | "configuration" | "callback" | "validation";
+declare class ApiError extends Error {
+    status: number;
+    fieldErrors: FieldErrors;
+    data?: unknown | undefined;
+    code: ApiErrorCode;
+    constructor(message: string, status?: number, fieldErrors?: FieldErrors, data?: unknown | undefined, code?: ApiErrorCode, cause?: unknown);
+}
+
+interface ApiSession {
+    userId: string;
+    token?: string | null;
+    tenantId?: string | null;
+}
+interface SessionSnapshot {
+    readonly userId: string | null;
+    readonly tenantId: string | null;
+    readonly revision: number;
+}
+
+/** Structural Standard Schema v1 support: Zod, Valibot and other compatible schemas need no runtime dependency here. */
+interface StandardSchema<T> {
+    readonly "~standard": {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => {
+            readonly value: T;
+            readonly issues?: undefined;
+        } | {
+            readonly issues: readonly {
+                readonly message: string;
+            }[];
+        } | Promise<{
+            readonly value: T;
+            readonly issues?: undefined;
+        } | {
+            readonly issues: readonly {
+                readonly message: string;
+            }[];
+        }>;
+    };
+}
+type ResponseSchema<T> = ((value: unknown) => T | Promise<T>) | {
+    parse(value: unknown): T;
+    parseAsync?: (value: unknown) => Promise<T>;
+} | StandardSchema<T>;
+
+type Params = Record<string, string | number | boolean | null | undefined | readonly (string | number | boolean)[]>;
+/** Uses each platform's native Fetch types without requiring DOM libs in Node projects. */
+type ApiHeaders = NonNullable<RequestInit["headers"]>;
+interface ApiResponse<T = unknown> {
+    readonly data: T | null;
+    readonly headers: Headers;
+    readonly status: number;
+    readonly statusText: string;
+    readonly url: string;
+}
+interface RequestOptions<T = unknown> {
+    /** Keep body-only results by default; full mode also exposes response metadata. */
+    responseMode?: "data" | "full";
+    schema?: ResponseSchema<T> | false;
+    authRetry?: boolean;
+    requiresAuth?: boolean;
+    method?: string;
+    params?: Params;
+    body?: unknown;
+    headers?: ApiHeaders;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+interface StreamOptions extends Omit<RequestOptions, "responseMode" | "schema"> {
+    /** text yields decoded UTF-8 chunks; sse yields complete SSE events. */
+    format?: "text" | "sse";
+    /** Maximum buffered SSE line/event length in UTF-16 code units. Default 1 MiB. */
+    maxEventSize?: number;
+}
+interface ServerSentEvent {
+    readonly event: string;
+    readonly data: string;
+    readonly id: string;
+    /** Server retry hint only; this client never reconnects automatically. */
+    readonly retry?: number;
+}
+interface ClientOptions {
+    baseUrl?: string;
+    session?: ApiSession | null;
+    /** Return a new access token. Shared across concurrent 401s and retried once. */
+    refreshToken?: (signal: AbortSignal, session: SessionSnapshot) => Promise<string>;
+    refreshTimeoutMs?: number;
+    schema?: ResponseSchema<unknown>;
+    getToken?: (signal: AbortSignal) => string | null | undefined | Promise<string | null | undefined>;
+    headers?: ApiHeaders;
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+    credentials?: RequestInit["credentials"];
+    normalizeErrors?: (data: unknown) => FieldErrors;
+    /** Non-secret stable identity for intentional cache sharing/SSR hydration. Unique per client by default. */
+    cacheScope?: string;
+    /** Additional HTTP(S) origins allowed to receive this client's requests and credentials. */
+    allowedOrigins?: readonly string[];
+}
+interface QueryConfig<T, S = T | null> {
+    schema?: ResponseSchema<T> | false;
+    requiresAuth?: boolean;
+    authRetry?: boolean;
+    key: readonly unknown[];
+    url: string;
+    params?: Params;
+    headers?: ApiHeaders;
+    /** Non-secret account/tenant identity; change on authentication transitions. */
+    cacheScope?: string;
+    timeoutMs?: number;
+    enabled?: boolean;
+    staleTime?: number;
+    retry?: boolean | number;
+    select?: (response: T | null) => S;
+}
+interface MutationConfig<T, V, S = T | null> {
+    schema?: ResponseSchema<T> | false;
+    requiresAuth?: boolean;
+    authRetry?: boolean;
+    url: string | ((variables: V) => string);
+    method?: string;
+    mapPayload?: (variables: V) => unknown;
+    headers?: ApiHeaders;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    select?: (response: T | null) => S;
+    invalidateKeys?: readonly (readonly unknown[])[];
+    /** all explicitly includes matching native TanStack queries in this QueryClient. */
+    invalidateScope?: "client" | "all";
+    onSuccess?: (data: S, variables: V) => unknown | Promise<unknown>;
+}
+
+declare const DEFAULT_TIMEOUT_MS = 15000;
+declare function createApiClient(config?: ClientOptions): Readonly<{
+    cacheScope: string;
+    queryKey: (key: readonly unknown[], url: string, params?: Params, headers?: ApiHeaders, scope?: string) => unknown[];
+    setSession: (value: ApiSession | null) => void;
+    logout: () => void;
+    getSessionSnapshot: () => SessionSnapshot;
+    subscribeSession: (listener: () => void) => () => void;
+    assertSession: (revision: number) => void;
+    withSession<T>(operation: () => T | Promise<T>, revision?: number): Promise<T>;
+    ownsQuery(key: readonly unknown[]): boolean;
+    request: {
+        <T = unknown>(url: string, request: RequestOptions<T> & {
+            responseMode: "full";
+        }): Promise<ApiResponse<T>>;
+        <T = unknown>(url: string, request?: RequestOptions<T> & {
+            responseMode?: "data";
+        }): Promise<T | null>;
+        <T = unknown>(url: string, request: RequestOptions<T>): Promise<T | null | ApiResponse<T>>;
+    };
+    stream: {
+        (url: string, request: StreamOptions & {
+            format: "sse";
+        }): AsyncGenerator<ServerSentEvent, void, unknown>;
+        (url: string, request?: StreamOptions & {
+            format?: "text";
+        }): AsyncGenerator<string, void, unknown>;
+        (url: string, request: StreamOptions): AsyncGenerator<string | ServerSentEvent, void, unknown>;
+    };
+}>;
+type ApiClient = ReturnType<typeof createApiClient>;
+
+export { DEFAULT_TIMEOUT_MS as D, ApiError as f, createApiClient as j };
+export type { ApiHeaders as A, ClientOptions as C, FieldErrors as F, MutationConfig as M, Params as P, QueryConfig as Q, RequestOptions as R, SessionSnapshot as S, ApiSession as a, ApiResponse as b, StreamOptions as c, ServerSentEvent as d, ApiClient as e, ApiErrorCode as g, ResponseSchema as h, StandardSchema as i };

package/dist/core/index.d.ts

@@ -0,0 +1,13 @@
+import { f as ApiError, F as FieldErrors, e as ApiClient, P as Params, A as ApiHeaders, M as MutationConfig } from '../client-ByBlZaRg.js';
+export { g as ApiErrorCode, b as ApiResponse, a as ApiSession, C as ClientOptions, D as DEFAULT_TIMEOUT_MS, Q as QueryConfig, R as RequestOptions, h as ResponseSchema, d as ServerSentEvent, S as SessionSnapshot, i as StandardSchema, c as StreamOptions, j as createApiClient } from '../client-ByBlZaRg.js';
+
+declare function invokeCallback<T>(callback: () => T): T;
+declare function invokeAsyncCallback(callback: () => unknown | Promise<unknown>): Promise<void>;
+
+declare function laravelErrors(data: unknown): FieldErrors;
+declare function queryIdentity(client: ApiClient, key: readonly unknown[], url: string, params?: Params, headers?: ApiHeaders, scope?: string): unknown[];
+declare function runMutation<T, V, S = T | null>(client: ApiClient, config: MutationConfig<T, V, S>, variables: V): Promise<S>;
+/** Avoid retries for deterministic schema/auth/client failures; honor adapter or QueryClient overrides. */
+declare function defaultQueryRetry(failureCount: number, error: ApiError): boolean;
+
+export { ApiClient, ApiError, ApiHeaders, FieldErrors, MutationConfig, Params, defaultQueryRetry, invokeAsyncCallback, invokeCallback, laravelErrors, queryIdentity, runMutation };

package/dist/core/index.js

@@ -0,0 +1,26 @@
+import {
+  DEFAULT_TIMEOUT_MS,
+  createApiClient,
+  defaultQueryRetry,
+  laravelErrors,
+  queryIdentity,
+  runMutation
+} from "../chunk-HDW7BOZI.js";
+import {
+  invokeAsyncCallback,
+  invokeCallback
+} from "../chunk-DXYWZQW5.js";
+import {
+  ApiError
+} from "../chunk-YTM3FV65.js";
+export {
+  ApiError,
+  DEFAULT_TIMEOUT_MS,
+  createApiClient,
+  defaultQueryRetry,
+  invokeAsyncCallback,
+  invokeCallback,
+  laravelErrors,
+  queryIdentity,
+  runMutation
+};

package/dist/react/index.d.ts

@@ -0,0 +1,16 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { QueryClient, UseMutationResult, UseQueryResult } from '@tanstack/react-query';
+import { ApiClient, MutationConfig, ApiError, QueryConfig, SessionSnapshot } from '../core/index.js';
+
+declare function ApiProvider({ client, queryClient, children, }: {
+    client: ApiClient;
+    queryClient?: QueryClient;
+    children: ReactNode;
+}): react.JSX.Element;
+declare function useApiClient(): ApiClient;
+declare function useApiSession(): SessionSnapshot;
+declare function useApiQuery<T = unknown, S = T | null>(config: QueryConfig<T, S>): UseQueryResult<S, ApiError>;
+declare function useApiMutation<T = unknown, V = unknown, S = T | null>(config: MutationConfig<T, V, S>): UseMutationResult<S, ApiError, V, unknown>;
+
+export { ApiProvider, useApiClient, useApiMutation, useApiQuery, useApiSession };

package/dist/react/index.js

@@ -0,0 +1,227 @@
+import {
+  defaultQueryRetry,
+  queryIdentity,
+  runMutation
+} from "../chunk-HDW7BOZI.js";
+import {
+  invokeAsyncCallback,
+  invokeCallback
+} from "../chunk-DXYWZQW5.js";
+import "../chunk-YTM3FV65.js";
+
+// src/react/index.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+  useSyncExternalStore
+} from "react";
+import {
+  QueryClient,
+  QueryClientProvider,
+  useQuery,
+  useMutation,
+  useQueryClient
+} from "@tanstack/react-query";
+import { jsx } from "react/jsx-runtime";
+var Context = createContext(null);
+function clearClientCache(client, cache, staleOnly = false) {
+  const current = client.getSessionSnapshot();
+  const predicate = (query) => {
+    if (!client.ownsQuery(query.queryKey)) return false;
+    if (!staleOnly) return true;
+    const snapshot = query.queryKey.at(-1).session;
+    return !snapshot || snapshot.revision !== current.revision || snapshot.userId !== current.userId || snapshot.tenantId !== current.tenantId;
+  };
+  void cache.cancelQueries({ predicate }).catch(() => {
+  });
+  cache.removeQueries({ predicate });
+  for (const mutation of cache.getMutationCache().getAll()) {
+    const variables = mutation.state.variables;
+    const revision = variables && typeof variables === "object" && "revision" in variables ? variables.revision : void 0;
+    if (mutation.options.meta?.universalApiLayer === client.cacheScope && (!staleOnly || revision !== current.revision))
+      cache.getMutationCache().remove(mutation);
+  }
+}
+var cacheBindings = /* @__PURE__ */ new WeakMap();
+function bindCache(client, cache) {
+  let caches = cacheBindings.get(client);
+  if (!caches) {
+    caches = /* @__PURE__ */ new WeakMap();
+    cacheBindings.set(client, caches);
+  }
+  let binding = caches.get(cache);
+  if (!binding) {
+    clearClientCache(client, cache, true);
+    binding = {
+      count: 0,
+      unsubscribe: client.subscribeSession(
+        () => clearClientCache(client, cache)
+      )
+    };
+    caches.set(cache, binding);
+  }
+  binding.count++;
+  const current = binding;
+  return () => {
+    current.count--;
+    if (current.count === 0) {
+      current.unsubscribe();
+      clearClientCache(client, cache);
+      caches.delete(cache);
+    }
+  };
+}
+function ApiProvider({
+  client,
+  queryClient,
+  children
+}) {
+  const [owned] = useState(() => queryClient ?? new QueryClient());
+  const cache = queryClient ?? owned;
+  const session = useSyncExternalStore(
+    client.subscribeSession,
+    client.getSessionSnapshot,
+    client.getSessionSnapshot
+  );
+  useEffect(() => bindCache(client, cache), [client, cache]);
+  const value = useMemo(() => ({ client, session }), [client, session]);
+  return /* @__PURE__ */ jsx(Context.Provider, { value, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: cache, children }) });
+}
+function useContextValue() {
+  const value = useContext(Context);
+  if (!value) throw new Error("Wrap your application in ApiProvider");
+  return value;
+}
+function useApiClient() {
+  return useContextValue().client;
+}
+function useApiSession() {
+  return useContextValue().session;
+}
+function useApiQuery(config) {
+  const { client, session } = useContextValue();
+  const cache = useQueryClient();
+  return useQuery({
+    queryKey: queryIdentity(
+      client,
+      config.key,
+      config.url,
+      config.params,
+      config.headers,
+      config.cacheScope
+    ),
+    queryFn: ({ signal }) => {
+      client.assertSession(session.revision);
+      return client.request(config.url, {
+        params: config.params,
+        headers: config.headers,
+        timeoutMs: config.timeoutMs,
+        signal,
+        schema: config.schema,
+        authRetry: config.authRetry,
+        requiresAuth: config.requiresAuth
+      });
+    },
+    select: config.select ? (data) => invokeCallback(() => config.select(data)) : void 0,
+    enabled: config.requiresAuth ? !!session.userId && config.enabled !== false : config.enabled,
+    staleTime: config.staleTime,
+    retry: config.retry ?? cache.getDefaultOptions().queries?.retry ?? defaultQueryRetry
+  });
+}
+function useApiMutation(config) {
+  const { client, session } = useContextValue();
+  const cache = useQueryClient();
+  const mutation = useMutation({
+    mutationKey: ["universal-api-layer", client.cacheScope, session.revision],
+    meta: { universalApiLayer: client.cacheScope },
+    mutationFn: async (envelope) => {
+      client.assertSession(envelope.revision);
+      const data = await runMutation(client, config, envelope.input);
+      client.assertSession(envelope.revision);
+      return data;
+    },
+    onSuccess: async (data, envelope) => {
+      client.assertSession(envelope.revision);
+      await Promise.all(
+        (config.invalidateKeys ?? []).map(
+          (queryKey) => cache.invalidateQueries({
+            queryKey,
+            predicate: config.invalidateScope === "all" ? void 0 : (query) => client.ownsQuery(query.queryKey)
+          })
+        )
+      );
+      client.assertSession(envelope.revision);
+      await invokeAsyncCallback(() => config.onSuccess?.(data, envelope.input));
+      client.assertSession(envelope.revision);
+    }
+  });
+  const translate = (options) => options ? {
+    onSuccess: (data, envelope, context, mutationContext) => {
+      if (envelope.revision === client.getSessionSnapshot().revision)
+        options.onSuccess?.(
+          data,
+          envelope.input,
+          context,
+          mutationContext
+        );
+    },
+    onError: (error, envelope, context, mutationContext) => {
+      if (envelope.revision === client.getSessionSnapshot().revision)
+        options.onError?.(
+          error,
+          envelope.input,
+          context,
+          mutationContext
+        );
+    },
+    onSettled: (data, error, envelope, context, mutationContext) => {
+      if (envelope.revision === client.getSessionSnapshot().revision)
+        options.onSettled?.(
+          data,
+          error,
+          envelope.input,
+          context,
+          mutationContext
+        );
+    }
+  } : void 0;
+  const current = !mutation.variables || mutation.variables.revision === session.revision;
+  return {
+    ...mutation,
+    ...!current ? {
+      data: void 0,
+      error: null,
+      context: void 0,
+      status: "idle",
+      isIdle: true,
+      isPending: false,
+      isSuccess: false,
+      isError: false,
+      isPaused: false,
+      submittedAt: 0,
+      failureCount: 0,
+      failureReason: null
+    } : {},
+    variables: current ? mutation.variables?.input : void 0,
+    mutate: (input, options) => mutation.mutate(
+      { input, revision: client.getSessionSnapshot().revision },
+      translate(options)
+    ),
+    mutateAsync: (input, options) => client.withSession(
+      () => mutation.mutateAsync(
+        { input, revision: client.getSessionSnapshot().revision },
+        translate(options)
+      )
+    )
+  };
+}
+export {
+  ApiProvider,
+  useApiClient,
+  useApiMutation,
+  useApiQuery,
+  useApiSession
+};