@treygrr/nuxt-airplane 0.0.0-stage → 0.1.2

package/dist/runtime/client.d.ts

@@ -0,0 +1,230 @@
+import { type MutationHandlers, type MutationRow, type AirplaneRequestOptions, type AirplaneRuntimeConfig, type AirplaneStores, type OperationDocument, type QueryHandlers, type QueryName } from './types.js';
+export interface AirplaneClientOptions extends AirplaneRuntimeConfig {
+    documents: Record<string, OperationDocument>;
+    /** Hash of the compiled documents, mixed into the cache key. */
+    documentsHash: string;
+    mutationHandlers: MutationHandlers;
+    queryHandlers: QueryHandlers;
+    stores: AirplaneStores;
+    request: AirplaneRequestOptions;
+    /** Runs a function inside the Nuxt app context (so composables work in `headers`). */
+    runWithContext?: <T>(fn: () => T) => T | Promise<Awaited<T>>;
+}
+/** What `useQuery` observes: the live data plus the cache row's metadata. */
+export interface QuerySnapshot {
+    data: unknown;
+    updatedAt: number | null;
+    /** A response for this query has been stored at some point. */
+    cached: boolean;
+}
+/** `ArchiveSite` → `Archive site`, `SendHTTPRequest` → `Send http request`, for mutations without a `describe`. */
+export declare function humanize(name: string): string;
+/** `undefined`, `null` and `{}` all mean "no variables" and share a key. */
+export declare function queryKey(name: string, variables: unknown): string;
+export type AirplaneClient = ReturnType<typeof createAirplaneClient>;
+export declare function createAirplaneClient(options: AirplaneClientOptions): {
+    db: import("./types.js").AirplaneDexie;
+    state: {
+        networkOnline: boolean;
+        forcedOffline: boolean;
+        readonly online: boolean;
+        syncing: boolean;
+        pending: {
+            id: number;
+            document: string;
+            variables: unknown;
+            status: import("./types.js").MutationStatus;
+            createdAt: number;
+            description: string;
+            error?: string | undefined;
+            undo?: {
+                table: string;
+                key: string | number | Date | void[][] | {
+                    readonly byteLength: number;
+                    slice: (begin?: number, end?: number) => ArrayBuffer;
+                    readonly maxByteLength: number;
+                    readonly resizable: boolean;
+                    resize: (newByteLength?: number) => void;
+                    readonly detached: boolean;
+                    transfer: (newByteLength?: number) => ArrayBuffer;
+                    transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                    readonly [Symbol.toStringTag]: "ArrayBuffer";
+                } | {
+                    readonly buffer: {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => ArrayBuffer;
+                        readonly maxByteLength: number;
+                        readonly resizable: boolean;
+                        resize: (newByteLength?: number) => void;
+                        readonly detached: boolean;
+                        transfer: (newByteLength?: number) => ArrayBuffer;
+                        transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                        readonly [Symbol.toStringTag]: "ArrayBuffer";
+                    } | {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                        readonly growable: boolean;
+                        readonly maxByteLength: number;
+                        grow: (newByteLength?: number) => void;
+                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                    };
+                    readonly byteLength: number;
+                    readonly byteOffset: number;
+                } | {
+                    readonly buffer: {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => ArrayBuffer;
+                        readonly maxByteLength: number;
+                        readonly resizable: boolean;
+                        resize: (newByteLength?: number) => void;
+                        readonly detached: boolean;
+                        transfer: (newByteLength?: number) => ArrayBuffer;
+                        transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                        readonly [Symbol.toStringTag]: "ArrayBuffer";
+                    } | {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                        readonly growable: boolean;
+                        readonly maxByteLength: number;
+                        grow: (newByteLength?: number) => void;
+                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                    };
+                    readonly byteLength: number;
+                    readonly byteOffset: number;
+                    getFloat32: (byteOffset: number, littleEndian?: boolean) => number;
+                    getFloat64: (byteOffset: number, littleEndian?: boolean) => number;
+                    getInt8: (byteOffset: number) => number;
+                    getInt16: (byteOffset: number, littleEndian?: boolean) => number;
+                    getInt32: (byteOffset: number, littleEndian?: boolean) => number;
+                    getUint8: (byteOffset: number) => number;
+                    getUint16: (byteOffset: number, littleEndian?: boolean) => number;
+                    getUint32: (byteOffset: number, littleEndian?: boolean) => number;
+                    setFloat32: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    setFloat64: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    setInt8: (byteOffset: number, value: number) => void;
+                    setInt16: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    setInt32: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    setUint8: (byteOffset: number, value: number) => void;
+                    setUint16: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    setUint32: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    getBigInt64: (byteOffset: number, littleEndian?: boolean) => bigint;
+                    getBigUint64: (byteOffset: number, littleEndian?: boolean) => bigint;
+                    setBigInt64: (byteOffset: number, value: bigint, littleEndian?: boolean) => void;
+                    setBigUint64: (byteOffset: number, value: bigint, littleEndian?: boolean) => void;
+                    getFloat16: (byteOffset: number, littleEndian?: boolean) => number;
+                    setFloat16: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    readonly [Symbol.toStringTag]: string;
+                } | readonly (string | number | Date | void[][] | {
+                    readonly byteLength: number;
+                    slice: (begin?: number, end?: number) => ArrayBuffer;
+                    readonly maxByteLength: number;
+                    readonly resizable: boolean;
+                    resize: (newByteLength?: number) => void;
+                    readonly detached: boolean;
+                    transfer: (newByteLength?: number) => ArrayBuffer;
+                    transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                    readonly [Symbol.toStringTag]: "ArrayBuffer";
+                } | {
+                    readonly buffer: {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => ArrayBuffer;
+                        readonly maxByteLength: number;
+                        readonly resizable: boolean;
+                        resize: (newByteLength?: number) => void;
+                        readonly detached: boolean;
+                        transfer: (newByteLength?: number) => ArrayBuffer;
+                        transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                        readonly [Symbol.toStringTag]: "ArrayBuffer";
+                    } | {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                        readonly growable: boolean;
+                        readonly maxByteLength: number;
+                        grow: (newByteLength?: number) => void;
+                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                    };
+                    readonly byteLength: number;
+                    readonly byteOffset: number;
+                } | {
+                    readonly buffer: {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => ArrayBuffer;
+                        readonly maxByteLength: number;
+                        readonly resizable: boolean;
+                        resize: (newByteLength?: number) => void;
+                        readonly detached: boolean;
+                        transfer: (newByteLength?: number) => ArrayBuffer;
+                        transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                        readonly [Symbol.toStringTag]: "ArrayBuffer";
+                    } | {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                        readonly growable: boolean;
+                        readonly maxByteLength: number;
+                        grow: (newByteLength?: number) => void;
+                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                    };
+                    readonly byteLength: number;
+                    readonly byteOffset: number;
+                    getFloat32: (byteOffset: number, littleEndian?: boolean) => number;
+                    getFloat64: (byteOffset: number, littleEndian?: boolean) => number;
+                    getInt8: (byteOffset: number) => number;
+                    getInt16: (byteOffset: number, littleEndian?: boolean) => number;
+                    getInt32: (byteOffset: number, littleEndian?: boolean) => number;
+                    getUint8: (byteOffset: number) => number;
+                    getUint16: (byteOffset: number, littleEndian?: boolean) => number;
+                    getUint32: (byteOffset: number, littleEndian?: boolean) => number;
+                    setFloat32: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    setFloat64: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    setInt8: (byteOffset: number, value: number) => void;
+                    setInt16: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    setInt32: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    setUint8: (byteOffset: number, value: number) => void;
+                    setUint16: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    setUint32: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    getBigInt64: (byteOffset: number, littleEndian?: boolean) => bigint;
+                    getBigUint64: (byteOffset: number, littleEndian?: boolean) => bigint;
+                    setBigInt64: (byteOffset: number, value: bigint, littleEndian?: boolean) => void;
+                    setBigUint64: (byteOffset: number, value: bigint, littleEndian?: boolean) => void;
+                    getFloat16: (byteOffset: number, littleEndian?: boolean) => number;
+                    setFloat16: (byteOffset: number, value: number, littleEndian?: boolean) => void;
+                    readonly [Symbol.toStringTag]: string;
+                })[];
+                before?: unknown;
+            }[] | undefined;
+        }[];
+        readonly blocked: number;
+        syncTotal: number;
+        syncCount: number;
+        lastError: string | null;
+        prefetching: number;
+    };
+    synced: import("vue").ComputedRef<boolean>;
+    documents: Record<string, OperationDocument>;
+    active: Map<string, () => Promise<void>>;
+    fetchQuery: <T>(name: string, variables: unknown) => Promise<T>;
+    prefetch: (name: string, variables: unknown, data: unknown) => Promise<void>;
+    watchQuery: (name: string, variables: unknown) => {
+        snapshot: Readonly<import("vue").Ref<{
+            readonly data: Readonly<unknown>;
+            readonly updatedAt: number | null;
+            readonly cached: boolean;
+        }, {
+            readonly data: Readonly<unknown>;
+            readonly updatedAt: number | null;
+            readonly cached: boolean;
+        }>>;
+        unsubscribe: () => void;
+    };
+    refetchActive: (only?: Iterable<QueryName>) => Promise<void>;
+    enqueue: (name: string, variables: unknown) => Promise<MutationRow>;
+    rollback: (id: number) => Promise<void>;
+    retry: (id: number) => Promise<void>;
+    sync: () => Promise<void>;
+    goOffline: () => void;
+    goOnline: () => void;
+    cacheKey: string;
+    ready: import("dexie").PromiseExtended<void>;
+    clear: () => Promise<void>;
+    clearCache: () => Promise<void>;
+};

package/dist/runtime/client.js

@@ -0,0 +1,361 @@
+import { liveQuery } from "dexie";
+import { hash } from "ohash";
+import { reactive, computed, shallowRef, readonly } from "vue";
+import { BOOKKEEPING_TABLES, applyUndo, createDb, withUndoLog } from "./db.js";
+import {
+  GraphQLRequestError
+} from "./types.js";
+export function humanize(name) {
+  const words = name.replace(/[_-]+/g, " ").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+export function queryKey(name, variables) {
+  const normalized = variables && typeof variables === "object" && Object.keys(variables).length ? variables : null;
+  return `${name}:${hash(normalized)}`;
+}
+export function createAirplaneClient(options) {
+  const db = createDb(options.dbName, options.stores.stores, options.stores.version);
+  const { documents, mutationHandlers, queryHandlers } = options;
+  const stopOnFailure = options.stopOnFailure ?? true;
+  const opened = db.open().catch(async (error) => {
+    if (!["VersionError", "UpgradeError", "SchemaError"].includes(error.name)) throw error;
+    console.warn(`[nuxt-airplane] Could not open "${options.dbName}" (${error.name}), recreating it. Bump the store version to migrate instead.`);
+    await db.delete();
+    await db.open();
+  });
+  const cacheKey = `${options.cacheKey ?? ""}:${options.documentsHash}`;
+  async function clearCache() {
+    const tables = db.tables.filter((t) => !BOOKKEEPING_TABLES.has(t.name));
+    await db.transaction("rw", tables, async () => {
+      for (const table of tables) await table.clear();
+    });
+  }
+  const ready = opened.then(async () => {
+    const stored = (await db.meta.get("cacheKey"))?.value;
+    if (stored !== void 0 && stored !== cacheKey) {
+      if (import.meta.dev) console.info(`[nuxt-airplane] Cache key changed, clearing cached data (outbox kept).`);
+      await clearCache();
+    }
+    if (stored !== cacheKey) await db.meta.put({ key: "cacheKey", value: cacheKey });
+    await requeueStuck();
+  });
+  async function requeueStuck() {
+    await db.mutations.where("status").equals("syncing").modify({ status: "pending" });
+  }
+  const state = reactive({
+    /** What the browser reports; assumed online where `navigator.onLine` does not exist (Node, some webviews). */
+    networkOnline: typeof navigator === "object" && typeof navigator.onLine === "boolean" ? navigator.onLine : true,
+    /** Set by `goOffline()`: behave as offline whatever the network says. */
+    forcedOffline: false,
+    /** Effective state the client acts on. */
+    get online() {
+      return this.networkOnline && !this.forcedOffline;
+    },
+    syncing: false,
+    /** Mutations still waiting to be sent, oldest first. */
+    pending: [],
+    /** Pending mutations held back because an older one failed; `0` with `stopOnFailure: false`. */
+    get blocked() {
+      if (!stopOnFailure) return 0;
+      const failed = this.pending.findIndex((m) => m.status === "failed");
+      return failed < 0 ? 0 : this.pending.slice(failed + 1).filter((m) => m.status === "pending").length;
+    },
+    /** Size of the batch the current (or last) sync started with. */
+    syncTotal: 0,
+    /** Mutations of that batch that have reached the server so far. */
+    syncCount: 0,
+    /** Current pending list could not be sent because of a network error */
+    lastError: null,
+    /** Paginated queries currently being walked to the end by `prefetch`. */
+    prefetching: 0
+  });
+  const synced = computed(() => !state.syncing && state.pending.length === 0);
+  liveQuery(() => db.mutations.orderBy("createdAt").toArray()).subscribe({ next: (rows) => state.pending = rows });
+  if (typeof window !== "undefined") {
+    window.addEventListener("online", () => {
+      state.networkOnline = true;
+      void sync();
+    });
+    window.addEventListener("offline", () => state.networkOnline = false);
+  }
+  function goOffline() {
+    state.forcedOffline = true;
+  }
+  function goOnline() {
+    state.forcedOffline = false;
+    void sync();
+  }
+  function document(name) {
+    const doc = documents[name];
+    if (!doc) throw new Error(`[nuxt-airplane] Unknown GraphQL document "${name}"`);
+    return doc;
+  }
+  async function requestHeaders(ctx) {
+    const headers = new Headers({ "content-type": "application/json", ...options.headers });
+    const { headers: dynamic } = options.request;
+    const extra = typeof dynamic === "function" ? await (options.runWithContext ? options.runWithContext(() => dynamic(ctx)) : dynamic(ctx)) : dynamic;
+    new Headers(extra ?? void 0).forEach((value, key) => headers.set(key, value));
+    return headers;
+  }
+  async function request(name, variables) {
+    const doc = document(name);
+    const ctx = { document: name, kind: doc.kind, variables };
+    const doFetch = options.request.fetch ?? globalThis.fetch;
+    const res = await doFetch(options.endpoint, {
+      method: "POST",
+      headers: await requestHeaders(ctx),
+      credentials: options.request.credentials,
+      body: JSON.stringify({ query: doc.source, variables: variables ?? void 0 }),
+      signal: AbortSignal.timeout(options.request.timeout ?? 3e4)
+    });
+    await options.request.onResponse?.(res, ctx);
+    const body = await res.json().catch(() => ({}));
+    if (body.errors?.length) throw new GraphQLRequestError(body.errors);
+    if (!res.ok) throw new Error(`[nuxt-airplane] ${res.status} ${res.statusText}`);
+    if (body.data == null) throw new Error("[nuxt-airplane] Response has no data");
+    return body.data;
+  }
+  function queryHandler(name) {
+    return queryHandlers[name];
+  }
+  const active = /* @__PURE__ */ new Map();
+  async function storeResponse(name, variables, data) {
+    const h = queryHandler(name);
+    const row = { key: queryKey(name, variables), document: name, variables, updatedAt: Date.now() };
+    await db.transaction("rw", db.tables, async () => {
+      await h?.store?.({ db, variables }, data);
+      await db.queries.put({ ...row, data: h?.read ? null : data });
+    });
+  }
+  async function fetchQuery(name, variables) {
+    await ready;
+    const data = await request(name, variables);
+    await storeResponse(name, variables, data);
+    await rebasePending();
+    if (queryHandler(name)?.prefetch) void prefetch(name, variables, data);
+    return data;
+  }
+  const prefetching = /* @__PURE__ */ new Set();
+  async function prefetch(name, variables, data) {
+    const p = queryHandler(name)?.prefetch;
+    if (!p || prefetching.has(name) || p.when && !p.when()) return;
+    prefetching.add(name);
+    state.prefetching++;
+    let pages = 0;
+    try {
+      let vars = variables;
+      let page = data;
+      while (state.online && pages < (p.maxPages ?? 1e3)) {
+        const next = p.next(page, vars);
+        if (!next) break;
+        vars = next;
+        page = await request(name, vars);
+        await storeResponse(name, vars, page);
+        pages++;
+      }
+    } catch (error) {
+      if (import.meta.dev) console.warn(`[nuxt-airplane] Prefetch of "${name}" stopped:`, error);
+    } finally {
+      prefetching.delete(name);
+      state.prefetching--;
+    }
+    if (pages) await rebasePending();
+  }
+  function watchQuery(name, variables) {
+    const snapshot = shallowRef({ data: null, updatedAt: null, cached: false });
+    const h = queryHandler(name);
+    const key = queryKey(name, variables);
+    const subscription = liveQuery(async () => {
+      const row = await db.queries.get(key);
+      const data = h?.read ? await h.read({ db, variables }) : row?.data;
+      const cached = h?.read ? !!row || await db.queries.where("document").equals(name).count() > 0 : !!row;
+      return { data: data ?? null, updatedAt: row?.updatedAt ?? null, cached };
+    }).subscribe({ next: (s) => snapshot.value = s });
+    return { snapshot: readonly(snapshot), unsubscribe: () => subscription.unsubscribe() };
+  }
+  async function refetchActive(only) {
+    const names = only && [...only];
+    await Promise.allSettled(
+      [...active.entries()].filter(([key]) => !names || names.some((name) => key.startsWith(`${name}:`))).map(([, refresh]) => refresh())
+    );
+  }
+  function createCacheApi(invalidated) {
+    async function updateRows(name, filter, updater) {
+      const rows = (await db.queries.where("document").equals(name).toArray()).filter((r) => filter(r.key));
+      const next = rows.filter((row) => row.data !== null && row.data !== void 0).map((row) => {
+        const data = structuredClone(row.data);
+        const returned = updater(data, row.variables);
+        return { ...row, data: returned === void 0 ? data : returned };
+      });
+      await db.queries.bulkPut(next);
+    }
+    return {
+      async update(name, variablesOrUpdater, maybeUpdater) {
+        if (typeof variablesOrUpdater === "function") {
+          await updateRows(name, () => true, variablesOrUpdater);
+        } else {
+          const key = queryKey(name, variablesOrUpdater);
+          await updateRows(name, (k) => k === key, maybeUpdater);
+        }
+      },
+      async get(name, variables) {
+        const h = queryHandler(name);
+        if (h?.read) return await h.read({ db, variables }) ?? void 0;
+        return (await db.queries.get(queryKey(name, variables)))?.data;
+      },
+      async set(name, variables, data) {
+        await db.queries.put({ key: queryKey(name, variables), document: name, variables, data, updatedAt: Date.now() });
+      },
+      async invalidate(name) {
+        await db.queries.where("document").equals(name).delete();
+        invalidated?.add(name);
+      }
+    };
+  }
+  function mutationHandler(name) {
+    return mutationHandlers[name];
+  }
+  async function applyMutation(row, { rebase = false } = {}) {
+    const h = mutationHandler(row.document);
+    if (!h?.apply) return;
+    const invalidated = /* @__PURE__ */ new Set();
+    const { undo } = await withUndoLog(db, () => h.apply({ db, cache: createCacheApi(invalidated), variables: row.variables }));
+    await db.mutations.update(row.id, { undo });
+    if (!rebase && invalidated.size) await refetchActive(invalidated);
+  }
+  async function rebasePending() {
+    const queue = await db.mutations.orderBy("createdAt").toArray();
+    for (const row of queue) await applyMutation(row, { rebase: true });
+  }
+  async function describeMutation(name, variables) {
+    const { describe } = mutationHandler(name) ?? {};
+    if (typeof describe === "string") return describe;
+    if (describe) return describe({ db, cache: createCacheApi(), variables });
+    return humanize(name);
+  }
+  async function enqueue(name, variables) {
+    if (document(name).kind !== "mutation") throw new Error(`[nuxt-airplane] "${name}" is not a mutation`);
+    await ready;
+    const description = await describeMutation(name, variables);
+    const id = await db.mutations.add({ document: name, variables, description, status: "pending", createdAt: Date.now() });
+    const row = await db.mutations.get(id);
+    try {
+      await applyMutation(row);
+    } catch (error) {
+      await db.mutations.delete(id);
+      throw error;
+    }
+    void sync();
+    return row;
+  }
+  async function rollback(id) {
+    const row = await db.mutations.get(id);
+    if (!row || row.status === "syncing") return;
+    const h = mutationHandler(row.document);
+    if (h?.revert) {
+      await h.revert({ db, cache: createCacheApi(), variables: row.variables });
+      await db.mutations.delete(id);
+    } else {
+      const later = (await db.mutations.where("id").above(row.id).toArray()).filter((m) => m.status !== "syncing");
+      if (row.undo) await applyUndo(db, row.undo);
+      await db.mutations.delete(id);
+      for (const m of later) await applyMutation(m, { rebase: true });
+    }
+    void sync();
+  }
+  async function retry(id) {
+    await db.mutations.update(id, { status: "pending", error: void 0 });
+    await sync();
+  }
+  let syncPromise = null;
+  function sync() {
+    if (syncPromise) return syncPromise;
+    syncPromise = runSyncLocked().finally(() => syncPromise = null);
+    return syncPromise;
+  }
+  async function sendable() {
+    const rows = await db.mutations.orderBy("createdAt").toArray();
+    const queue = [];
+    for (const row of rows) {
+      if (row.status === "failed" && stopOnFailure) break;
+      if (row.status === "pending") queue.push(row);
+    }
+    return queue;
+  }
+  const syncLock = `nuxt-airplane:sync:${options.dbName}`;
+  async function runSyncLocked() {
+    const locks = typeof navigator === "object" ? navigator.locks : void 0;
+    if (!locks) return runSync();
+    await locks.request(syncLock, async () => {
+      await ready;
+      await requeueStuck();
+      await runSync();
+    });
+  }
+  async function runSync() {
+    await ready;
+    if (!state.online) return;
+    const queue = await sendable();
+    if (!queue.length) return;
+    state.syncing = true;
+    state.syncTotal = queue.length;
+    state.syncCount = 0;
+    state.lastError = null;
+    const refetch = /* @__PURE__ */ new Set();
+    let refetchAll = false;
+    try {
+      for (const row of queue) {
+        await db.mutations.update(row.id, { status: "syncing" });
+        try {
+          const result = await request(row.document, row.variables);
+          const h = mutationHandler(row.document);
+          await h?.reconcile?.({ db, cache: createCacheApi(), variables: row.variables }, result);
+          if (h?.refetch) h.refetch.forEach((n) => refetch.add(n));
+          else refetchAll = true;
+          await db.mutations.delete(row.id);
+          state.syncCount++;
+        } catch (error) {
+          if (error instanceof GraphQLRequestError) {
+            await db.mutations.update(row.id, { status: "failed", error: error.message });
+            if (stopOnFailure) break;
+            continue;
+          }
+          await db.mutations.update(row.id, { status: "pending" });
+          state.lastError = error instanceof Error ? error.message : String(error);
+          break;
+        }
+      }
+    } finally {
+      state.syncing = false;
+    }
+    if (state.syncCount) await refetchActive(refetchAll ? void 0 : refetch);
+  }
+  async function clear() {
+    await db.transaction("rw", db.tables, async () => {
+      for (const table of db.tables) await table.clear();
+    });
+    await db.meta.put({ key: "cacheKey", value: cacheKey });
+  }
+  void sync();
+  return {
+    db,
+    state,
+    synced,
+    documents,
+    active,
+    fetchQuery,
+    prefetch,
+    watchQuery,
+    refetchActive,
+    enqueue,
+    rollback,
+    retry,
+    sync,
+    goOffline,
+    goOnline,
+    cacheKey,
+    ready,
+    clear,
+    clearCache
+  };
+}

package/dist/runtime/composables/defineAirplaneRequest.d.ts

@@ -0,0 +1,7 @@
+import { type AirplaneRequestOptions } from '../types.js';
+/**
+ * Configure how requests reach the GraphQL endpoint: auth headers, credentials,
+ * a custom fetch, a response hook. Default-export it from a file under the
+ * handlers directory. Several files are merged, last one wins per option.
+ */
+export declare function defineAirplaneRequest(options: AirplaneRequestOptions): AirplaneRequestOptions;

package/dist/runtime/composables/defineAirplaneRequest.js

@@ -0,0 +1,4 @@
+import { HANDLER_KIND } from "../types.js";
+export function defineAirplaneRequest(options) {
+  return Object.defineProperty(options, HANDLER_KIND, { value: "request" });
+}

package/dist/runtime/composables/defineAirplaneStores.d.ts

@@ -0,0 +1,8 @@
+import { type AirplaneStores } from '../types.js';
+/**
+ * Add tables to the module's Dexie database, in Dexie's `stores()` syntax.
+ * Augment the global `NuxtAirplaneStores` interface to type their rows.
+ */
+export declare function defineAirplaneStores(stores: Record<string, string>, options?: {
+    version?: number;
+}): AirplaneStores;

package/dist/runtime/composables/defineAirplaneStores.js

@@ -0,0 +1,4 @@
+import { HANDLER_KIND } from "../types.js";
+export function defineAirplaneStores(stores, options = {}) {
+  return Object.defineProperty({ stores, version: options.version }, HANDLER_KIND, { value: "stores" });
+}

package/dist/runtime/composables/defineMutationHandler.d.ts

@@ -0,0 +1,6 @@
+import { type MutationHandler, type MutationHandlers, type MutationName } from '../types.js';
+/**
+ * Declare the handler of a single mutation, typed by its document name. Handy
+ * for one file per mutation; the results can be spread into `defineMutationHandlers`.
+ */
+export declare function defineMutationHandler<N extends MutationName>(name: N, handler: MutationHandler<N>): MutationHandlers;

package/dist/runtime/composables/defineMutationHandler.js

@@ -0,0 +1,4 @@
+import { HANDLER_KIND } from "../types.js";
+export function defineMutationHandler(name, handler) {
+  return Object.defineProperty({ [name]: handler }, HANDLER_KIND, { value: "mutations" });
+}

package/dist/runtime/composables/defineMutationHandlers.d.ts

@@ -0,0 +1,6 @@
+import { type MutationHandlers } from '../types.js';
+/**
+ * Declare how queued mutations touch the local data. Files under `airplane/`
+ * (the handlers directory) that default-export one of these are picked up automatically.
+ */
+export declare function defineMutationHandlers(handlers: MutationHandlers): MutationHandlers;

package/dist/runtime/composables/defineMutationHandlers.js

@@ -0,0 +1,4 @@
+import { HANDLER_KIND } from "../types.js";
+export function defineMutationHandlers(handlers) {
+  return Object.defineProperty(handlers, HANDLER_KIND, { value: "mutations" });
+}

package/dist/runtime/composables/defineQueryHandler.d.ts

@@ -0,0 +1,6 @@
+import { type QueryHandler, type QueryHandlers, type QueryName } from '../types.js';
+/**
+ * Declare the handler of a single query, typed by its document name. Handy
+ * for one file per query; the results can be spread into `defineQueryHandlers`.
+ */
+export declare function defineQueryHandler<N extends QueryName>(name: N, handler: QueryHandler<N>): QueryHandlers;

package/dist/runtime/composables/defineQueryHandler.js

@@ -0,0 +1,4 @@
+import { HANDLER_KIND } from "../types.js";
+export function defineQueryHandler(name, handler) {
+  return Object.defineProperty({ [name]: handler }, HANDLER_KIND, { value: "queries" });
+}

package/dist/runtime/composables/defineQueryHandlers.d.ts

@@ -0,0 +1,6 @@
+import { type QueryHandlers } from '../types.js';
+/**
+ * Declare how query responses are stored in, and read back from, your own
+ * tables. Queries without a handler are cached as-is.
+ */
+export declare function defineQueryHandlers(handlers: QueryHandlers): QueryHandlers;