@lunora/client 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/OfflineQueue-BI0FNNvc.mjs

@@ -0,0 +1 @@
+export { O as OfflineQueue, n as nextId, r as reportPersistenceError } from './offline-queue-7Wc4onA0.mjs';

package/dist/packem_shared/SKIP-vItZChkw.mjs

@@ -0,0 +1,50 @@
+const SKIP = "skip";
+const toSubscriptionError = (error) => {
+  if (error instanceof Error) {
+    return { message: error.message };
+  }
+  return { message: String(error) };
+};
+const createQuerySubscription = (client, function_, args, sinks, options = {}) => {
+  if (args === SKIP) {
+    sinks.onReset?.();
+    return () => {
+    };
+  }
+  let cancelled = false;
+  const handleError = (error) => {
+    if (cancelled) {
+      return;
+    }
+    sinks.onError?.(error);
+  };
+  const onError = sinks.onError ? handleError : void 0;
+  let unsubscribe;
+  try {
+    unsubscribe = client.subscribe(
+      function_,
+      args,
+      (value) => {
+        if (cancelled) {
+          return;
+        }
+        sinks.onData(value);
+      },
+      { onError, shardKey: options.shardKey }
+    );
+  } catch (error) {
+    if (!sinks.onError) {
+      throw error;
+    }
+    handleError(toSubscriptionError(error));
+    return () => {
+      cancelled = true;
+    };
+  }
+  return () => {
+    cancelled = true;
+    unsubscribe();
+  };
+};
+
+export { SKIP, createQuerySubscription, toSubscriptionError };

package/dist/packem_shared/SubscriptionRegistry-Dn-7k7eo.mjs

@@ -0,0 +1 @@
+export { S as SubscriptionRegistry } from './subscription-C1Jy7HiF.mjs';

package/dist/packem_shared/applyDelta-4jFGTPA3.mjs

@@ -0,0 +1,61 @@
+const ID_FIELD = "_id";
+const CREATION_FIELD = "_creationTime";
+const rowId = (row) => {
+  if (typeof row !== "object" || row === null) {
+    return void 0;
+  }
+  const id = row[ID_FIELD];
+  return typeof id === "string" ? id : void 0;
+};
+const insertionIndex = (list, row) => {
+  const creation = row[CREATION_FIELD];
+  if (typeof creation !== "number") {
+    return list.length;
+  }
+  for (const [index, existingRow] of list.entries()) {
+    const existing = existingRow[CREATION_FIELD];
+    if (typeof existing === "number" && existing > creation) {
+      return index;
+    }
+  }
+  return list.length;
+};
+const isMutationDelta = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate["key"] === "string" && typeof candidate["table"] === "string" && (candidate["op"] === "insert" || candidate["op"] === "update" || candidate["op"] === "delete");
+};
+const applyDelta = (current, delta) => {
+  if (!Array.isArray(current)) {
+    return void 0;
+  }
+  const rows = [];
+  for (const element of current) {
+    const id = rowId(element);
+    if (id === void 0) {
+      return void 0;
+    }
+    rows.push(element);
+  }
+  const { key, op, row } = delta;
+  if (op === "delete") {
+    const next2 = rows.filter((existing) => existing[ID_FIELD] !== key);
+    return next2.length === rows.length ? [...rows] : next2;
+  }
+  if (row === void 0) {
+    return void 0;
+  }
+  const existingIndex = rows.findIndex((existing) => existing[ID_FIELD] === key);
+  if (existingIndex === -1) {
+    const next2 = [...rows];
+    next2.splice(insertionIndex(rows, row), 0, row);
+    return next2;
+  }
+  const next = [...rows];
+  next[existingIndex] = row;
+  return next;
+};
+
+export { applyDelta, isMutationDelta };

package/dist/packem_shared/createAsyncStoragePersistence-1Z5BZ8RC.mjs

@@ -0,0 +1,45 @@
+const DEFAULT_KEY = "lunora:offline-mutations";
+const createAsyncStoragePersistence = (options) => {
+  const { storage } = options;
+  const key = options.key ?? DEFAULT_KEY;
+  let chain = Promise.resolve();
+  const serialize = (run) => {
+    const next = chain.then(run, run);
+    chain = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  };
+  const readAll = async () => {
+    const raw = await storage.getItem(key);
+    if (raw === null) {
+      return [];
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  };
+  const writeAll = (mutations) => storage.setItem(key, JSON.stringify(mutations));
+  return {
+    append: (mutation) => serialize(async () => {
+      const mutations = await readAll();
+      mutations.push(mutation);
+      await writeAll(mutations);
+    }),
+    clear: () => serialize(() => storage.removeItem(key)),
+    load: () => serialize(readAll),
+    remove: (id) => serialize(async () => {
+      const mutations = await readAll();
+      const remaining = mutations.filter((mutation) => mutation.id !== id);
+      if (remaining.length !== mutations.length) {
+        await writeAll(remaining);
+      }
+    })
+  };
+};
+
+export { createAsyncStoragePersistence };

package/dist/packem_shared/createInMemoryBookmarkStorage-BoN7a7TH.mjs

@@ -0,0 +1,11 @@
+const createInMemoryBookmarkStorage = () => {
+  let value = null;
+  return {
+    get: () => value,
+    set: (next) => {
+      value = next;
+    }
+  };
+};
+
+export { createInMemoryBookmarkStorage as default };

package/dist/packem_shared/createInMemoryPersistence-CW82inU5.mjs

@@ -0,0 +1,105 @@
+const createInMemoryPersistence = () => {
+  const entries = /* @__PURE__ */ new Map();
+  const clone = (mutation) => {
+    return {
+      args: { ...mutation.args },
+      functionPath: mutation.functionPath,
+      id: mutation.id,
+      identity: mutation.identity,
+      shardKey: mutation.shardKey
+    };
+  };
+  return {
+    append: (mutation) => {
+      entries.set(mutation.id, clone(mutation));
+      return Promise.resolve();
+    },
+    clear: () => {
+      entries.clear();
+      return Promise.resolve();
+    },
+    load: () => Promise.resolve([...entries.values()].map((mutation) => clone(mutation))),
+    remove: (id) => {
+      entries.delete(id);
+      return Promise.resolve();
+    }
+  };
+};
+const DEFAULT_DATABASE = "lunora";
+const DEFAULT_STORE = "offline-mutations";
+const ID_INDEX = "by_id";
+const promisifyRequest = (request) => new Promise((resolve, reject) => {
+  request.addEventListener("success", () => {
+    resolve(request.result);
+  });
+  request.addEventListener("error", () => {
+    reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+});
+const createIndexedDbPersistence = (options = {}) => {
+  const factory = options.indexedDB ?? (typeof indexedDB === "undefined" ? void 0 : indexedDB);
+  if (!factory) {
+    throw new Error("createIndexedDbPersistence: no IndexedDB available — pass `indexedDB` or use createInMemoryPersistence()");
+  }
+  const databaseName = options.databaseName ?? DEFAULT_DATABASE;
+  const storeName = options.storeName ?? DEFAULT_STORE;
+  let databasePromise;
+  const openDatabase = () => {
+    if (databasePromise) {
+      return databasePromise;
+    }
+    databasePromise = new Promise((resolve, reject) => {
+      const request = factory.open(databaseName, 1);
+      request.addEventListener("upgradeneeded", () => {
+        const database = request.result;
+        if (!database.objectStoreNames.contains(storeName)) {
+          const store = database.createObjectStore(storeName, { autoIncrement: true });
+          store.createIndex(ID_INDEX, "id", { unique: true });
+        }
+      });
+      request.addEventListener("success", () => {
+        resolve(request.result);
+      });
+      request.addEventListener("error", () => {
+        reject(request.error ?? new Error("IndexedDB open failed"));
+      });
+    });
+    return databasePromise;
+  };
+  const withStore = async (mode, run) => {
+    const database = await openDatabase();
+    const transaction = database.transaction(storeName, mode);
+    const result = await run(transaction.objectStore(storeName));
+    await new Promise((resolve, reject) => {
+      transaction.addEventListener("complete", () => {
+        resolve();
+      });
+      transaction.addEventListener("error", () => {
+        reject(transaction.error ?? new Error("IndexedDB transaction failed"));
+      });
+      transaction.addEventListener("abort", () => {
+        reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
+      });
+    });
+    return result;
+  };
+  return {
+    append: async (mutation) => {
+      await withStore("readwrite", (store) => promisifyRequest(store.add(mutation)));
+    },
+    clear: async () => {
+      await withStore("readwrite", (store) => promisifyRequest(store.clear()));
+    },
+    load: async () => withStore("readonly", (store) => promisifyRequest(store.getAll())),
+    remove: async (id) => {
+      await withStore("readwrite", async (store) => {
+        const key = await promisifyRequest(store.index(ID_INDEX).getKey(id));
+        if (key !== void 0) {
+          await promisifyRequest(store.delete(key));
+        }
+      });
+    }
+  };
+};
+
+export { createInMemoryPersistence, createIndexedDbPersistence };

package/dist/packem_shared/createInMemoryQueryCache-B1PQ9Twl.mjs

@@ -0,0 +1,138 @@
+const queryCacheKey = (functionPath, argsKey, shardKey) => `${functionPath}::${argsKey}::${shardKey ?? ""}`;
+const DEFAULT_MAX_ENTRIES = 500;
+const createInMemoryQueryCache = (options = {}) => {
+  const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  const entries = /* @__PURE__ */ new Map();
+  const clone = (entry) => {
+    return { ...entry, value: structuredClone(entry.value) };
+  };
+  const evict = () => {
+    if (entries.size <= maxEntries) {
+      return;
+    }
+    const ordered = [...entries.values()].toSorted((a, b) => a.ts - b.ts);
+    for (const entry of ordered) {
+      if (entries.size <= maxEntries) {
+        break;
+      }
+      entries.delete(entry.key);
+    }
+  };
+  return {
+    clear: () => {
+      entries.clear();
+      return Promise.resolve();
+    },
+    load: () => Promise.resolve([...entries.values()].map((entry) => clone(entry))),
+    put: (key, entry) => {
+      entries.set(key, clone({ ...entry, key }));
+      evict();
+      return Promise.resolve();
+    },
+    remove: (key) => {
+      entries.delete(key);
+      return Promise.resolve();
+    }
+  };
+};
+const DEFAULT_DATABASE = "lunora";
+const DEFAULT_STORE = "query-cache";
+const TS_INDEX = "by_ts";
+const DATABASE_VERSION = 2;
+const promisifyRequest = (request) => new Promise((resolve, reject) => {
+  request.addEventListener("success", () => {
+    resolve(request.result);
+  });
+  request.addEventListener("error", () => {
+    reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+});
+const createIndexedDbQueryCache = (options = {}) => {
+  const factory = options.indexedDB ?? (typeof indexedDB === "undefined" ? void 0 : indexedDB);
+  if (!factory) {
+    throw new Error("createIndexedDbQueryCache: no IndexedDB available — pass `indexedDB` or use createInMemoryQueryCache()");
+  }
+  const databaseName = options.databaseName ?? DEFAULT_DATABASE;
+  const storeName = options.storeName ?? DEFAULT_STORE;
+  const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  let databasePromise;
+  const openDatabase = () => {
+    if (databasePromise) {
+      return databasePromise;
+    }
+    databasePromise = new Promise((resolve, reject) => {
+      const request = factory.open(databaseName, DATABASE_VERSION);
+      request.addEventListener("upgradeneeded", () => {
+        const database = request.result;
+        if (!database.objectStoreNames.contains(storeName)) {
+          const store = database.createObjectStore(storeName, { keyPath: "key" });
+          store.createIndex(TS_INDEX, "ts", { unique: false });
+        }
+      });
+      request.addEventListener("success", () => {
+        resolve(request.result);
+      });
+      request.addEventListener("error", () => {
+        reject(request.error ?? new Error("IndexedDB open failed"));
+      });
+    });
+    return databasePromise;
+  };
+  const withStore = async (mode, run) => {
+    const database = await openDatabase();
+    const transaction = database.transaction(storeName, mode);
+    const result = await run(transaction.objectStore(storeName));
+    await new Promise((resolve, reject) => {
+      transaction.addEventListener("complete", () => {
+        resolve();
+      });
+      transaction.addEventListener("error", () => {
+        reject(transaction.error ?? new Error("IndexedDB transaction failed"));
+      });
+      transaction.addEventListener("abort", () => {
+        reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
+      });
+    });
+    return result;
+  };
+  const evict = async (store) => {
+    const count = await promisifyRequest(store.count());
+    let overflow = count - maxEntries;
+    if (overflow <= 0) {
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const cursorRequest = store.index(TS_INDEX).openCursor();
+      cursorRequest.addEventListener("success", () => {
+        const cursor = cursorRequest.result;
+        if (!cursor || overflow <= 0) {
+          resolve();
+          return;
+        }
+        cursor.delete();
+        overflow -= 1;
+        cursor.continue();
+      });
+      cursorRequest.addEventListener("error", () => {
+        reject(cursorRequest.error ?? new Error("IndexedDB eviction failed"));
+      });
+    });
+  };
+  return {
+    clear: async () => {
+      await withStore("readwrite", (store) => promisifyRequest(store.clear()));
+    },
+    load: async () => withStore("readonly", (store) => promisifyRequest(store.getAll())),
+    put: async (key, entry) => {
+      await withStore("readwrite", async (store) => {
+        await promisifyRequest(store.put({ ...entry, key }));
+        await evict(store);
+      });
+    },
+    remove: async (key) => {
+      await withStore("readwrite", (store) => promisifyRequest(store.delete(key)));
+    }
+  };
+};
+
+export { createInMemoryQueryCache, createIndexedDbQueryCache, queryCacheKey };

package/dist/packem_shared/createLocalStore-IOur0jHF.mjs

@@ -0,0 +1 @@
+export { c as createLocalStore } from './local-store-BNgN3Dw3.mjs';

package/dist/packem_shared/createMutationRunner-BqsavzvG.mjs

@@ -0,0 +1,21 @@
+const createMutationRunner = (client, function_, sinks) => {
+  let inFlight = 0;
+  return async (args, options) => {
+    inFlight += 1;
+    sinks.setPending(true);
+    try {
+      const result = await client.mutation(function_, args, options);
+      sinks.setResult(result);
+      return result;
+    } catch (error) {
+      const normalized = error instanceof Error ? error : new Error(String(error));
+      sinks.setError(normalized);
+      throw normalized;
+    } finally {
+      inFlight -= 1;
+      sinks.setPending(inFlight > 0);
+    }
+  };
+};
+
+export { createMutationRunner };

package/dist/packem_shared/createMutatorRunner-BETvCd0p.mjs

@@ -0,0 +1,31 @@
+const createMutatorRunner = (handle, sinks) => {
+  let inFlight = 0;
+  let latestInvocation = 0;
+  const mutate = async (args) => {
+    latestInvocation += 1;
+    const invocation = latestInvocation;
+    inFlight += 1;
+    sinks.setPending(true);
+    try {
+      await handle(args).isPersisted.promise;
+      if (invocation === latestInvocation) {
+        sinks.setError(void 0);
+      }
+    } catch (error) {
+      const normalized = error instanceof Error ? error : new Error(String(error));
+      if (invocation === latestInvocation) {
+        sinks.setError(normalized);
+      }
+      throw normalized;
+    } finally {
+      inFlight -= 1;
+      sinks.setPending(inFlight > 0);
+    }
+  };
+  const reset = () => {
+    sinks.setError(void 0);
+  };
+  return { mutate, reset };
+};
+
+export { createMutatorRunner };

package/dist/packem_shared/createReconnect-Di_-oHH7.mjs

@@ -0,0 +1,22 @@
+const createReconnect = (options = {}, random = Math.random) => {
+  const initialDelayMs = options.initialDelayMs ?? 250;
+  const maxDelayMs = options.maxDelayMs ?? 3e4;
+  const jitter = options.jitter ?? true;
+  let attempt = 0;
+  return {
+    next() {
+      const exponential = Math.min(maxDelayMs, initialDelayMs * 2 ** attempt);
+      attempt += 1;
+      if (!jitter) {
+        return exponential;
+      }
+      const min = exponential / 2;
+      return Math.floor(min + random() * (exponential - min));
+    },
+    reset() {
+      attempt = 0;
+    }
+  };
+};
+
+export { createReconnect };

package/dist/packem_shared/createServerClient-BxkNcRlR.mjs

@@ -0,0 +1,11 @@
+import { LunoraClient } from './LunoraClient-CgZ6FhKP.mjs';
+
+const createServerClient = (options) => {
+  const client = new LunoraClient({ fetch: options.fetch, url: options.url });
+  if (options.token !== void 0) {
+    client.setAuthToken(options.token);
+  }
+  return client;
+};
+
+export { createServerClient };

package/dist/packem_shared/deserializePreloaded-C0eJTY_W.mjs

@@ -0,0 +1,4 @@
+const serializePreloaded = (preloaded) => JSON.stringify(preloaded).replaceAll("<", String.raw`\u003c`);
+const deserializePreloaded = (serialized) => JSON.parse(serialized);
+
+export { deserializePreloaded, serializePreloaded };

package/dist/packem_shared/getServerSession-8jXewqxd.mjs

@@ -0,0 +1,13 @@
+const extractHeaders = (source) => {
+  if (source instanceof Headers) {
+    return source;
+  }
+  return source.headers;
+};
+const getServerSession = async (request, auth) => {
+  const headers = extractHeaders(request);
+  const result = await auth.api.getSession({ headers });
+  return result ?? null;
+};
+
+export { getServerSession };

package/dist/packem_shared/local-store-BNgN3Dw3.mjs

@@ -0,0 +1,111 @@
+const foldOptimistic = (base, layers) => {
+  let value = base;
+  for (const layer of layers) {
+    try {
+      value = layer.transform(value);
+    } catch {
+    }
+  }
+  return value;
+};
+const notifySubscription = (state, value) => {
+  if (value === state.lastValue) {
+    return;
+  }
+  state.lastValue = value;
+  for (const callback of state.callbacks) {
+    try {
+      callback(value);
+    } catch {
+    }
+  }
+};
+const applyOptimisticLayer = (state, optimistic) => {
+  let next;
+  try {
+    next = optimistic(state.lastValue);
+  } catch {
+    return void 0;
+  }
+  const layer = { id: /* @__PURE__ */ Symbol("optimistic"), transform: optimistic };
+  state.optimisticLayers.push(layer);
+  notifySubscription(state, next);
+  const remove = () => {
+    const index = state.optimisticLayers.findIndex((entry) => entry.id === layer.id);
+    if (index === -1) {
+      return false;
+    }
+    state.optimisticLayers.splice(index, 1);
+    return true;
+  };
+  const refold = () => {
+    notifySubscription(state, foldOptimistic(state.serverBase, state.optimisticLayers));
+  };
+  return {
+    confirm: (commitCursor) => {
+      if (commitCursor === void 0) {
+        remove();
+        return;
+      }
+      layer.commitCursor = commitCursor;
+      if (state.serverCursor !== void 0 && state.serverCursor >= commitCursor && remove()) {
+        refold();
+      }
+    },
+    rollback: () => {
+      if (remove()) {
+        refold();
+      }
+    }
+  };
+};
+const dropConfirmedLayers = (state, cursor) => {
+  if (cursor === void 0 || state.optimisticLayers.length === 0) {
+    return false;
+  }
+  const before = state.optimisticLayers.length;
+  state.optimisticLayers = state.optimisticLayers.filter((layer) => layer.commitCursor === void 0 || layer.commitCursor > cursor);
+  return state.optimisticLayers.length !== before;
+};
+
+const createLocalStore = (subscriptions, shardKey, stableStringify) => {
+  const confirms = [];
+  const rollbacks = [];
+  const findState = (functionRef, argsKey) => {
+    for (const state of subscriptions.all()) {
+      if (state.fn.__lunoraRef === functionRef && state.shardKey === shardKey && state.argsKey === argsKey) {
+        return state;
+      }
+    }
+    return void 0;
+  };
+  const store = {
+    getAllQueries: (function_) => {
+      const matches = [];
+      for (const state of subscriptions.all()) {
+        if (state.fn.__lunoraRef === function_.__lunoraRef && state.shardKey === shardKey) {
+          matches.push({ args: state.args, value: state.lastValue });
+        }
+      }
+      return matches;
+    },
+    getQuery: (function_, args) => {
+      const state = findState(function_.__lunoraRef, stableStringify(args ?? {}));
+      return state?.lastValue;
+    },
+    setQuery: (function_, args, value) => {
+      const state = findState(function_.__lunoraRef, stableStringify(args ?? {}));
+      if (!state) {
+        return;
+      }
+      const handle = applyOptimisticLayer(state, () => value);
+      if (handle) {
+        confirms.push(handle.confirm);
+        rollbacks.push(handle.rollback);
+      }
+    }
+  };
+  return { confirms, rollbacks, store };
+};
+
+export { applyOptimisticLayer as a, createLocalStore as c, dropConfirmedLayers as d, foldOptimistic as f, notifySubscription as n };