@treygrr/nuxt-airplane 0.0.0-stage → 0.1.2

package/dist/runtime/composables/defineQueryHandlers.js

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

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

@@ -0,0 +1,3 @@
+import type { AirplaneClient } from '../client.js';
+/** The airplane client behind every composable. Only available in the browser. */
+export declare function useAirplane(): AirplaneClient | undefined;

package/dist/runtime/composables/useAirplane.js

@@ -0,0 +1,4 @@
+import { useNuxtApp } from "#app";
+export function useAirplane() {
+  return useNuxtApp().$airplane;
+}

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

@@ -0,0 +1,14 @@
+import { type Ref } from 'vue';
+import type { MutationName, MutationRow, MutationVariables } from '../types.js';
+export interface UseMutationReturn<V> {
+    /**
+     * Applies the mutation to the local cache and queues it for the server.
+     * Resolves with the outbox entry as soon as the change is visible locally;
+     * the request itself is sent in the background by the sync loop.
+     */
+    mutate: (variables: V) => Promise<MutationRow>;
+    /** `true` while the local `apply` handler runs. */
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+}
+export declare function useMutation<N extends MutationName>(name: N): UseMutationReturn<MutationVariables<N>>;

package/dist/runtime/composables/useMutation.js

@@ -0,0 +1,21 @@
+import { ref, shallowRef } from "vue";
+import { useAirplane } from "./useAirplane.js";
+export function useMutation(name) {
+  const loading = ref(false);
+  const error = shallowRef(null);
+  const client = useAirplane();
+  async function mutate(variables) {
+    if (!client) throw new Error("[nuxt-airplane] Mutations can only run on the client");
+    loading.value = true;
+    error.value = null;
+    try {
+      return await client.enqueue(name, variables);
+    } catch (e) {
+      error.value = e;
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return { mutate, loading, error };
+}

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

@@ -0,0 +1,19 @@
+import { type MaybeRefOrGetter, type Ref } from 'vue';
+import type { QueryName, QueryResult, QueryVariables } from '../types.js';
+export interface UseQueryOptions {
+    /** Set to `false` to only read the cache, never the network. */
+    fetch?: boolean;
+}
+export interface UseQueryReturn<T> {
+    /** Live data from the local cache. Updates when mutations touch it. */
+    data: Ref<T | null>;
+    /** `true` until the cache has been read and (if online) the first fetch is done. */
+    loading: Ref<boolean>;
+    /** `true` while a network request is in flight. */
+    fetching: Ref<boolean>;
+    error: Ref<Error | null>;
+    /** When the cached data was last fetched from the server, or `null`. */
+    updatedAt: Ref<number | null>;
+    refresh: () => Promise<void>;
+}
+export declare function useQuery<N extends QueryName>(name: N, variables?: MaybeRefOrGetter<QueryVariables<N> | undefined>, options?: UseQueryOptions): UseQueryReturn<QueryResult<N>>;

package/dist/runtime/composables/useQuery.js

@@ -0,0 +1,63 @@
+import { computed, getCurrentInstance, onMounted, onScopeDispose, ref, shallowRef, toValue, watch } from "vue";
+import { queryKey } from "../client.js";
+import { useAirplane } from "./useAirplane.js";
+export function useQuery(name, variables, options = {}) {
+  const data = shallowRef(null);
+  const loading = ref(true);
+  const fetching = ref(false);
+  const error = shallowRef(null);
+  const updatedAt = ref(null);
+  const client = useAirplane();
+  if (!client) {
+    return { data, loading, fetching, error, updatedAt, refresh: async () => {
+    } };
+  }
+  const vars = computed(() => toValue(variables));
+  const key = computed(() => queryKey(name, vars.value));
+  async function refresh() {
+    if (options.fetch === false || !client.state.online) return;
+    fetching.value = true;
+    try {
+      await client.fetchQuery(name, vars.value);
+      error.value = null;
+    } catch (e) {
+      error.value = e;
+    } finally {
+      fetching.value = false;
+      loading.value = false;
+    }
+  }
+  let stopWatch;
+  function subscribe() {
+    stopWatch?.();
+    const { snapshot, unsubscribe } = client.watchQuery(name, vars.value);
+    const stop = watch(snapshot, (s) => {
+      data.value = s.data ?? null;
+      updatedAt.value = s.updatedAt;
+      if (s.cached) loading.value = false;
+    }, { immediate: true });
+    stopWatch = () => {
+      stop();
+      unsubscribe();
+    };
+  }
+  watch(key, (next, prev) => {
+    client.active.delete(prev);
+    client.active.set(next, refresh);
+    loading.value = true;
+    subscribe();
+    void refresh();
+  });
+  function start() {
+    client.active.set(key.value, refresh);
+    subscribe();
+    void refresh();
+  }
+  if (getCurrentInstance()) onMounted(start);
+  else start();
+  onScopeDispose(() => {
+    client.active.delete(key.value);
+    stopWatch?.();
+  });
+  return { data, loading, fetching, error, updatedAt, refresh };
+}

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

@@ -0,0 +1,37 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { MutationRow } from '../types.js';
+export interface UseSyncReturn {
+    /** Effective state: the browser reports a connection and `goOffline()` is not in effect. */
+    online: Ref<boolean>;
+    /** What the browser reports, ignoring `goOffline()`. */
+    networkOnline: Ref<boolean>;
+    /** `true` while held offline by `goOffline()`. */
+    forcedOffline: Ref<boolean>;
+    /** A sync batch is being sent. */
+    syncing: Ref<boolean>;
+    /** Nothing is queued and nothing is being sent. */
+    synced: ComputedRef<boolean>;
+    /** Mutations still waiting to reach the server, oldest first. */
+    pending: Ref<MutationRow[]>;
+    /** Pending mutations held back because an older one failed (see the `stopOnFailure` option). */
+    blocked: Ref<number>;
+    /** Size of the batch the current (or last) sync started with. */
+    syncTotal: Ref<number>;
+    /** How many of that batch have been sent so far. */
+    syncCount: Ref<number>;
+    /** Message of the network error that stopped the last sync, if any. */
+    lastError: Ref<string | null>;
+    /** Paginated queries currently being fetched to the end for offline use. */
+    prefetching: Ref<number>;
+    /** Send the queue now. Does nothing while offline. */
+    sync: () => Promise<void>;
+    /** Undo a queued mutation and remove it from the queue. */
+    rollback: (id: number) => Promise<void>;
+    /** Put a failed mutation back in the queue and sync. */
+    retry: (id: number) => Promise<void>;
+    /** Hold the client offline regardless of the network until `goOnline()`. */
+    goOffline: () => void;
+    /** Release `goOffline()` and sync the queue. */
+    goOnline: () => void;
+}
+export declare function useSync(): UseSyncReturn;

package/dist/runtime/composables/useSync.js

@@ -0,0 +1,48 @@
+import { computed, toRef } from "vue";
+import { useAirplane } from "./useAirplane.js";
+export function useSync() {
+  const client = useAirplane();
+  if (!client) {
+    const off = async () => {
+    };
+    return {
+      online: computed(() => true),
+      networkOnline: computed(() => true),
+      forcedOffline: computed(() => false),
+      syncing: computed(() => false),
+      synced: computed(() => true),
+      pending: computed(() => []),
+      blocked: computed(() => 0),
+      syncTotal: computed(() => 0),
+      syncCount: computed(() => 0),
+      lastError: computed(() => null),
+      prefetching: computed(() => 0),
+      sync: off,
+      rollback: off,
+      retry: off,
+      goOffline: () => {
+      },
+      goOnline: () => {
+      }
+    };
+  }
+  const { state } = client;
+  return {
+    online: toRef(state, "online"),
+    networkOnline: toRef(state, "networkOnline"),
+    forcedOffline: toRef(state, "forcedOffline"),
+    syncing: toRef(state, "syncing"),
+    synced: client.synced,
+    pending: toRef(state, "pending"),
+    blocked: toRef(state, "blocked"),
+    syncTotal: toRef(state, "syncTotal"),
+    syncCount: toRef(state, "syncCount"),
+    lastError: toRef(state, "lastError"),
+    prefetching: toRef(state, "prefetching"),
+    sync: client.sync,
+    rollback: client.rollback,
+    retry: client.retry,
+    goOffline: client.goOffline,
+    goOnline: client.goOnline
+  };
+}

package/dist/runtime/db.d.ts

@@ -0,0 +1,26 @@
+import type { AirplaneDexie, UndoEntry } from './types.js';
+export declare const MODULE_STORES: {
+    queries: string;
+    mutations: string;
+    meta: string;
+};
+/** Tables that hold module bookkeeping rather than cached data. */
+export declare const BOOKKEEPING_TABLES: Set<string>;
+export interface CreateDbOptions {
+    /**
+     * Warn (once per table and index) when a boolean is written to an indexed
+     * key path, since IndexedDB cannot index booleans. Defaults to dev mode.
+     */
+    warnOnBooleanIndex?: boolean;
+}
+export declare function createDb(name: string, stores?: Record<string, string>, version?: number, { warnOnBooleanIndex }?: CreateDbOptions): AirplaneDexie;
+/**
+ * Runs `fn` in a read-write transaction over every table and returns the
+ * writes it made. If `fn` throws, the transaction aborts and nothing is kept.
+ */
+export declare function withUndoLog<T>(db: AirplaneDexie, fn: () => Promise<T> | T): Promise<{
+    result: T;
+    undo: UndoEntry[];
+}>;
+/** Puts rows back as they were, newest write first. */
+export declare function applyUndo(db: AirplaneDexie, undo: UndoEntry[]): Promise<void>;

package/dist/runtime/db.js

@@ -0,0 +1,109 @@
+import { Dexie } from "dexie";
+export const MODULE_STORES = {
+  queries: "&key, document, updatedAt",
+  mutations: "++id, status, createdAt",
+  meta: "&key"
+};
+export const BOOKKEEPING_TABLES = /* @__PURE__ */ new Set(["mutations", "meta"]);
+export function createDb(name, stores = {}, version = 1, { warnOnBooleanIndex = import.meta.dev } = {}) {
+  const db = new Dexie(name);
+  db.version(version).stores({ ...MODULE_STORES, ...stores });
+  installUndoLog(db, warnOnBooleanIndex);
+  return db;
+}
+function valueAt(row, keyPath) {
+  return keyPath.split(".").reduce((o, k) => o && typeof o === "object" ? o[k] : void 0, row);
+}
+function warnBooleanIndexes(table, values, warned) {
+  const { primaryKey, indexes } = table.schema;
+  for (const index of [primaryKey, ...indexes]) {
+    if (!index.keyPath || index.name?.includes("(virtual-from:")) continue;
+    const label = index.name ?? "primary key";
+    const id = `${table.name}/${label}`;
+    if (warned.has(id)) continue;
+    const paths = Array.isArray(index.keyPath) ? index.keyPath : [index.keyPath];
+    for (const value of values) {
+      const at = paths.findIndex((path) => typeof valueAt(value, path) === "boolean");
+      if (at === -1) continue;
+      warned.add(id);
+      const where = paths.length > 1 ? `index "${label}" at "${paths[at]}"` : `index "${label}"`;
+      console.warn(`[nuxt-airplane] Table "${table.name}": ${where} received a boolean, and IndexedDB cannot index booleans; store it as 0 | 1 (see the docs on stores).`);
+      break;
+    }
+  }
+}
+const logs = /* @__PURE__ */ new WeakMap();
+function keysOf(index, values) {
+  return index.extractKey ? values.map((v) => index.extractKey(v)) : void 0;
+}
+async function recordBefore(table, req) {
+  const pk = table.schema.primaryKey;
+  const trans = req.trans;
+  const name = table.name;
+  if (req.type === "deleteRange") {
+    const values = (await table.query({ trans, query: { index: pk, range: req.range }, values: true })).result;
+    const keys2 = keysOf(pk, values) ?? (await table.query({ trans, query: { index: pk, range: req.range }, values: false })).result;
+    return { entries: values.map((before2, i) => ({ table: name, key: keys2[i], before: before2 })) };
+  }
+  if (req.type === "delete") {
+    const before2 = await table.getMany({ trans, keys: req.keys });
+    return { entries: req.keys.map((key, i) => ({ table: name, key, before: before2[i] })) };
+  }
+  const keys = req.keys ?? keysOf(pk, req.values);
+  if (!keys) {
+    const entries = [];
+    return { entries, afterMutate: (result) => result.forEach((key) => entries.push({ table: name, key })) };
+  }
+  const before = await table.getMany({ trans, keys });
+  return { entries: keys.map((key, i) => ({ table: name, key, before: before[i] })) };
+}
+function installUndoLog(db, warnOnBooleanIndex = false) {
+  const warned = /* @__PURE__ */ new Set();
+  db.use({
+    stack: "dbcore",
+    name: "nuxt-airplane-undo",
+    create: (core) => ({
+      ...core,
+      table(name) {
+        const table = core.table(name);
+        if (BOOKKEEPING_TABLES.has(name)) return table;
+        return {
+          ...table,
+          async mutate(req) {
+            if (warnOnBooleanIndex && (req.type === "add" || req.type === "put")) warnBooleanIndexes(table, req.values, warned);
+            const log = logs.get(req.trans);
+            if (!log) return table.mutate(req);
+            const { entries, afterMutate } = await recordBefore(table, req);
+            const res = await table.mutate(req);
+            afterMutate?.(res.results ?? []);
+            log.push(...entries);
+            return res;
+          }
+        };
+      }
+    })
+  });
+}
+export async function withUndoLog(db, fn) {
+  const undo = [];
+  const result = await db.transaction("rw", db.tables, async () => {
+    const idbtrans = Dexie.currentTransaction.idbtrans;
+    logs.set(idbtrans, undo);
+    try {
+      return await fn();
+    } finally {
+      logs.delete(idbtrans);
+    }
+  });
+  return { result, undo };
+}
+export async function applyUndo(db, undo) {
+  await db.transaction("rw", db.tables, async () => {
+    for (const entry of [...undo].reverse()) {
+      const table = db.table(entry.table);
+      if (entry.before === void 0) await table.delete(entry.key);
+      else if (table.schema.primKey.keyPath) await table.put(entry.before);
+      else await table.put(entry.before, entry.key);
+    }
+  });
+}