@lunora/client 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/packem_shared/OfflineQueue-GGYJRmhF.mjs

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

package/dist/packem_shared/SubscriptionRegistry-DjGKZsqq.mjs

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

package/dist/packem_shared/{applyDelta-4jFGTPA3.mjs → applyDelta-CRKZ1PBt.mjs}

@@ -7,14 +7,34 @@ const rowId = (row) => {
   const id = row[ID_FIELD];
   return typeof id === "string" ? id : void 0;
 };
+const isDescending = (list) => {
+  let previous;
+  for (const existingRow of list) {
+    const existing = existingRow[CREATION_FIELD];
+    if (typeof existing !== "number") {
+      continue;
+    }
+    if (previous !== void 0) {
+      if (existing < previous) {
+        return true;
+      }
+      if (existing > previous) {
+        return false;
+      }
+    }
+    previous = existing;
+  }
+  return false;
+};
 const insertionIndex = (list, row) => {
   const creation = row[CREATION_FIELD];
   if (typeof creation !== "number") {
     return list.length;
   }
+  const descending = isDescending(list);
   for (const [index, existingRow] of list.entries()) {
     const existing = existingRow[CREATION_FIELD];
-    if (typeof existing === "number" && existing > creation) {
+    if (typeof existing === "number" && (descending ? existing < creation : existing > creation)) {
       return index;
     }
   }

package/dist/packem_shared/createInMemoryPersistence-DZ2VHWgm.mjs

@@ -0,0 +1,79 @@
+import { LunoraError } from '@lunora/errors';
+import { p as promisifyRequest, c as createWithStore, a as createDatabaseOpener } from './idb-utility-DrSVX43Q.mjs';
+
+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-outbox";
+const DEFAULT_STORE = "offline-mutations";
+const ID_INDEX = "by_id";
+const createIndexedDbPersistence = (options = {}) => {
+  const factory = options.indexedDB ?? (typeof indexedDB === "undefined" ? void 0 : indexedDB);
+  if (!factory) {
+    throw new LunoraError("INTERNAL", "createIndexedDbPersistence: no IndexedDB available — pass `indexedDB` or use createInMemoryPersistence()");
+  }
+  const databaseName = options.databaseName ?? DEFAULT_DATABASE;
+  const storeName = options.storeName ?? DEFAULT_STORE;
+  const openDatabase = createDatabaseOpener(factory, databaseName, 1, (database) => {
+    if (!database.objectStoreNames.contains(storeName)) {
+      const store = database.createObjectStore(storeName, { autoIncrement: true });
+      store.createIndex(ID_INDEX, "id", { unique: true });
+    }
+  });
+  const withStore = createWithStore(openDatabase, storeName);
+  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));
+        }
+      });
+    }
+  };
+};
+const resolvePersistenceAdapter = (option, autoProbe = true) => {
+  if (option === false) {
+    return void 0;
+  }
+  if (option) {
+    return option;
+  }
+  if (!autoProbe || typeof indexedDB === "undefined") {
+    return void 0;
+  }
+  return createIndexedDbPersistence();
+};
+
+export { createInMemoryPersistence, createIndexedDbPersistence, resolvePersistenceAdapter };

package/dist/packem_shared/{createInMemoryQueryCache-B1PQ9Twl.mjs → createInMemoryQueryCache-DiaGZkA2.mjs}

@@ -1,3 +1,6 @@
+import { LunoraError } from '@lunora/errors';
+import { p as promisifyRequest, c as createWithStore, a as createDatabaseOpener } from './idb-utility-DrSVX43Q.mjs';
+
 const queryCacheKey = (functionPath, argsKey, shardKey) => `${functionPath}::${argsKey}::${shardKey ?? ""}`;
 const DEFAULT_MAX_ENTRIES = 500;
 const createInMemoryQueryCache = (options = {}) => {
@@ -35,66 +38,25 @@ const createInMemoryQueryCache = (options = {}) => {
     }
   };
 };
-const DEFAULT_DATABASE = "lunora";
+const DEFAULT_DATABASE = "lunora-query-cache";
 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 DATABASE_VERSION = 1;
 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()");
+    throw new LunoraError("INTERNAL", "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;
+  const openDatabase = createDatabaseOpener(factory, databaseName, DATABASE_VERSION, (database) => {
+    if (!database.objectStoreNames.contains(storeName)) {
+      const store = database.createObjectStore(storeName, { keyPath: "key" });
+      store.createIndex(TS_INDEX, "ts", { unique: false });
     }
-    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 withStore = createWithStore(openDatabase, storeName);
   const evict = async (store) => {
     const count = await promisifyRequest(store.count());
     let overflow = count - maxEntries;
@@ -134,5 +96,17 @@ const createIndexedDbQueryCache = (options = {}) => {
     }
   };
 };
+const resolveQueryCacheAdapter = (option) => {
+  if (option === false) {
+    return void 0;
+  }
+  if (option) {
+    return option;
+  }
+  if (typeof indexedDB === "undefined") {
+    return void 0;
+  }
+  return createIndexedDbQueryCache();
+};
 
-export { createInMemoryQueryCache, createIndexedDbQueryCache, queryCacheKey };
+export { createInMemoryQueryCache, createIndexedDbQueryCache, queryCacheKey, resolveQueryCacheAdapter };

package/dist/packem_shared/createLocalStore-jRoqmazl.mjs

@@ -0,0 +1,2 @@
+export { c as createLocalStore } from './local-store-BveBeFEo.mjs';
+import './subscription-BjynOXCU.mjs';

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/{createServerClient-BjZc3gD8.mjs → createServerClient-DF-3mLmb.mjs}

@@ -1,4 +1,4 @@
-import { LunoraClient } from './LunoraClient-UiULzH_1.mjs';
+import { LunoraClient } from './LunoraClient-kXpHNyaE.mjs';
 
 const createServerClient = (options) => {
   const client = new LunoraClient({ fetch: options.fetch, url: options.url });

package/dist/packem_shared/idb-utility-DrSVX43Q.mjs

@@ -0,0 +1,48 @@
+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 createDatabaseOpener = (factory, databaseName, version, upgrade) => {
+  let databasePromise;
+  return () => {
+    if (databasePromise) {
+      return databasePromise;
+    }
+    databasePromise = new Promise((resolve, reject) => {
+      const request = factory.open(databaseName, version);
+      request.addEventListener("upgradeneeded", () => {
+        upgrade(request.result);
+      });
+      request.addEventListener("success", () => {
+        resolve(request.result);
+      });
+      request.addEventListener("error", () => {
+        reject(request.error ?? new Error("IndexedDB open failed"));
+      });
+    });
+    return databasePromise;
+  };
+};
+const createWithStore = (open, storeName) => async (mode, run) => {
+  const database = await open();
+  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;
+};
+
+export { createDatabaseOpener as a, createWithStore as c, promisifyRequest as p };

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

@@ -0,0 +1,106 @@
+import { S as SubscriptionRegistry } from './subscription-BjynOXCU.mjs';
+
+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) => {
+  const confirms = [];
+  const rollbacks = [];
+  const findState = (functionRef, args) => subscriptions.get(SubscriptionRegistry.key(functionRef, args, shardKey));
+  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, args ?? {});
+      return state?.lastValue;
+    },
+    setQuery: (function_, args, value) => {
+      const state = findState(function_.__lunoraRef, 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 };