@lunora/client 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/OfflineQueue-D5p_QgF_.mjs

@@ -0,0 +1,127 @@
+let idCounter = 0;
+const nextId = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  idCounter += 1;
+  return `m_${Date.now().toString(36)}_${idCounter.toString(36)}`;
+};
+const reportPersistenceError = (handler, operation, error, mutationId) => {
+  if (handler) {
+    handler({ error, mutationId, operation });
+    return;
+  }
+  console.warn(`[lunora] offline-queue persistence ${operation} failed`, error);
+};
+class OfflineQueue {
+  /** Opt-in to queueing mutations before the targeted shard's first connect. */
+  queueBeforeFirstConnect;
+  maxItems;
+  onPersistenceError;
+  persistence;
+  items = [];
+  constructor(options = {}, persistence) {
+    this.maxItems = options.maxItems ?? 1e3;
+    this.queueBeforeFirstConnect = options.queueBeforeFirstConnect ?? false;
+    this.onPersistenceError = options.onPersistenceError;
+    this.persistence = persistence;
+  }
+  get size() {
+    return this.items.length;
+  }
+  enqueue(entry) {
+    const item = entry;
+    item.id ??= nextId();
+    this.items.push(item);
+    this.persistence?.append({ args: item.args, functionPath: item.functionPath, id: item.id, identity: item.identity, shardKey: item.shardKey }).catch((error) => {
+      reportPersistenceError(this.onPersistenceError, "append", error, item.id);
+    });
+    while (this.items.length > this.maxItems) {
+      const dropped = this.items.shift();
+      if (dropped) {
+        if (dropped.id) {
+          this.persistence?.remove(dropped.id).catch((error2) => {
+            reportPersistenceError(this.onPersistenceError, "remove", error2, dropped.id);
+          });
+        }
+        const error = new Error("offline queue overflow");
+        error.code = "OFFLINE_QUEUE_OVERFLOW";
+        dropped.reject(error);
+      }
+    }
+  }
+  /**
+   * Restore mutations persisted in a prior session and re-queue them in FIFO
+   * order. Restored entries already live in durable storage, so they are not
+   * re-appended; they carry no-op `resolve`/`reject` (the original awaiter is
+   * gone after a reload). No-op when no persistence adapter is configured.
+   * Returns the distinct shard keys of the restored writes so the caller can
+   * open their sockets to trigger a flush.
+   */
+  async hydrate() {
+    if (!this.persistence) {
+      return [];
+    }
+    const persisted = await this.persistence.load();
+    const shardKeys = /* @__PURE__ */ new Set();
+    for (const mutation of persisted) {
+      if (this.items.some((item) => item.id === mutation.id)) {
+        continue;
+      }
+      this.items.push({
+        args: mutation.args,
+        functionPath: mutation.functionPath,
+        id: mutation.id,
+        identity: mutation.identity,
+        reject: () => void 0,
+        resolve: () => void 0,
+        shardKey: mutation.shardKey
+      });
+      shardKeys.add(mutation.shardKey);
+    }
+    return [...shardKeys];
+  }
+  /**
+   * Remove and return queued mutations. With no `predicate`, drains the whole
+   * queue. With one, drains only matching entries (preserving FIFO order) and
+   * leaves the rest queued — used to flush a single shard's writes when its
+   * socket reconnects while other shards are still down.
+   */
+  drain(predicate) {
+    if (!predicate) {
+      const drained2 = [...this.items];
+      this.items.length = 0;
+      return drained2;
+    }
+    const drained = [];
+    const kept = [];
+    for (const item of this.items) {
+      (predicate(item) ? drained : kept).push(item);
+    }
+    this.items.length = 0;
+    this.items.push(...kept);
+    return drained;
+  }
+  /**
+   * Return previously-drained mutations to the front of the queue, preserving
+   * their FIFO order, without re-persisting them — they were never unpersisted,
+   * so durable storage still holds them. Used when a flush aborts on a transient
+   * transport failure: the unreplayed writes stay queued for the next reconnect.
+   */
+  requeue(items) {
+    if (items.length === 0) {
+      return;
+    }
+    this.items.unshift(...items);
+  }
+  clear() {
+    for (const item of this.items) {
+      const error = new Error("CLIENT_CLOSED");
+      error.code = "CLIENT_CLOSED";
+      item.reject(error);
+    }
+    this.items.length = 0;
+  }
+}
+
+export { OfflineQueue, nextId, reportPersistenceError };

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-B-Qx_Gux.mjs

@@ -0,0 +1,26 @@
+class SubscriptionRegistry {
+  static key(functionPath, args, shardKey) {
+    return `${functionPath}::${JSON.stringify(args)}::${shardKey ?? ""}`;
+  }
+  byKey = /* @__PURE__ */ new Map();
+  byId = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.byKey.get(key);
+  }
+  getById(id) {
+    return this.byId.get(id);
+  }
+  add(state) {
+    this.byKey.set(SubscriptionRegistry.key(state.fn.__lunoraRef, state.args, state.shardKey), state);
+    this.byId.set(state.id, state);
+  }
+  remove(state) {
+    this.byKey.delete(SubscriptionRegistry.key(state.fn.__lunoraRef, state.args, state.shardKey));
+    this.byId.delete(state.id);
+  }
+  all() {
+    return [...this.byKey.values()];
+  }
+}
+
+export { SubscriptionRegistry };

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-DSUfoLqY.mjs

@@ -0,0 +1,36 @@
+const createLocalStore = (subscriptions, shardKey, write, stableStringify) => {
+  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;
+      }
+      rollbacks.push(write(state, value));
+    }
+  };
+  return { rollbacks, store };
+};
+
+export { createLocalStore };

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/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-BjZc3gD8.mjs

@@ -0,0 +1,11 @@
+import { LunoraClient } from './LunoraClient-UiULzH_1.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 };