@noy-db/hub 0.4.0-pre.6 → 0.4.0-pre.8

package/dist/chunk-EIPVYUEP.js

@@ -0,0 +1,654 @@
+// src/with-store/route-store.ts
+var BLOB_CHUNKS = "_blob_chunks";
+var BLOB_INDEX = "_blob_index";
+var BLOB_SLOTS = "_blob_slots_";
+var BLOB_VERSIONS = "_blob_versions_";
+function routeStore(opts) {
+  const primary = opts.default;
+  const blobsIsSimple = opts.blobs && "get" in opts.blobs;
+  const simpleBlobStore = blobsIsSimple ? opts.blobs : void 0;
+  const tieredBlobs = !blobsIsSimple ? opts.blobs : void 0;
+  const blobThreshold = tieredBlobs?.threshold ?? 400 * 1024;
+  const allStores = /* @__PURE__ */ new Set([primary]);
+  if (simpleBlobStore) allStores.add(simpleBlobStore);
+  if (tieredBlobs?.large) allStores.add(tieredBlobs.large);
+  if (tieredBlobs?.small) allStores.add(tieredBlobs.small);
+  if (opts.age?.cold) allStores.add(opts.age.cold);
+  if (opts.routes) for (const s of Object.values(opts.routes)) allStores.add(s);
+  if (opts.vaultRoutes) for (const s of Object.values(opts.vaultRoutes)) allStores.add(s);
+  if (opts.blobRoutes) for (const s of Object.values(opts.blobRoutes)) allStores.add(s);
+  if (opts.overflow) allStores.add(opts.overflow);
+  if (opts.blobLifecycle?.archiveStore) allStores.add(opts.blobLifecycle.archiveStore);
+  const overrides = /* @__PURE__ */ new Map();
+  const suspended = /* @__PURE__ */ new Set();
+  const writeQueues = /* @__PURE__ */ new Map();
+  const NULL_STORE = {
+    name: "suspended",
+    async get() {
+      return null;
+    },
+    async put() {
+    },
+    async delete() {
+    },
+    async list() {
+      return [];
+    },
+    async loadAll() {
+      return {};
+    },
+    async saveAll() {
+    }
+  };
+  function routeNameFor(vault, collection) {
+    if (opts.vaultRoutes) {
+      for (const prefix of Object.keys(opts.vaultRoutes)) {
+        if (vault.startsWith(prefix)) return prefix;
+      }
+    }
+    if (opts.routes && !collection.startsWith("_") && opts.routes[collection]) {
+      return collection;
+    }
+    if (isBlobChunks(collection) && (simpleBlobStore || tieredBlobs)) return "blobs";
+    if (opts.routeBlobMeta && isBlobMeta(collection) && (simpleBlobStore || tieredBlobs)) return "blobs";
+    if (opts.age && !collection.startsWith("_")) {
+    }
+    return "default";
+  }
+  const quotaExceeded = false;
+  function resolveOriginalStore(route) {
+    if (route === "blobs") return simpleBlobStore ?? tieredBlobs?.large ?? primary;
+    if (route === "cold") return opts.age?.cold ?? primary;
+    if (opts.routes?.[route]) return opts.routes[route];
+    if (opts.vaultRoutes?.[route]) return opts.vaultRoutes[route];
+    return primary;
+  }
+  function maybeQueueWrite(routeName, method, vault, collection, id, envelope, expectedVersion) {
+    if (!suspended.has(routeName)) return false;
+    const queue = writeQueues.get(routeName);
+    if (!queue) return false;
+    if (queue.writes.length >= queue.maxSize) {
+      queue.writes.shift();
+    }
+    queue.writes.push({
+      method,
+      vault,
+      collection,
+      id,
+      ...envelope !== void 0 ? { envelope } : {},
+      ...expectedVersion !== void 0 ? { expectedVersion } : {}
+    });
+    return true;
+  }
+  function isBlobChunks(collection) {
+    return collection === BLOB_CHUNKS;
+  }
+  function isBlobMeta(collection) {
+    return collection === BLOB_INDEX || collection.startsWith(BLOB_SLOTS) || collection.startsWith(BLOB_VERSIONS);
+  }
+  function isInternal(collection) {
+    return collection.startsWith("_");
+  }
+  function storeFor(vault, collection) {
+    const rName = routeNameFor(vault, collection);
+    if (suspended.has(rName)) return NULL_STORE;
+    if (overrides.has(rName)) return overrides.get(rName);
+    if (opts.vaultRoutes) {
+      for (const [prefix, store2] of Object.entries(opts.vaultRoutes)) {
+        if (vault.startsWith(prefix)) return store2;
+      }
+    }
+    if (opts.routes && !isInternal(collection) && opts.routes[collection]) {
+      return opts.routes[collection];
+    }
+    if (isBlobChunks(collection)) {
+      if (simpleBlobStore) return simpleBlobStore;
+      if (tieredBlobs) return tieredBlobs.large;
+    }
+    if (opts.routeBlobMeta && isBlobMeta(collection)) {
+      if (simpleBlobStore) return simpleBlobStore;
+      if (tieredBlobs) return tieredBlobs.large;
+    }
+    if (quotaExceeded && opts.overflow) return opts.overflow;
+    return primary;
+  }
+  function blobStoreForSize(dataSize) {
+    if (!tieredBlobs) return simpleBlobStore ?? primary;
+    if (dataSize <= blobThreshold) {
+      return tieredBlobs.small ?? primary;
+    }
+    return tieredBlobs.large;
+  }
+  function isCold(collection, envelope, before) {
+    if (!opts.age) return false;
+    if (isInternal(collection)) return false;
+    if (opts.age.collections && opts.age.collections.length > 0) {
+      if (!opts.age.collections.includes(collection)) return false;
+    }
+    const cutoffIso = before ?? (opts.age.coldAfterDays != null ? new Date(Date.now() - opts.age.coldAfterDays * 24 * 60 * 60 * 1e3).toISOString() : void 0);
+    if (cutoffIso === void 0) return false;
+    return envelope._ts < cutoffIso;
+  }
+  const store = {
+    name: buildName(),
+    ...opts.age?.cold ? { capabilities: { ...primary.capabilities, coldArchival: true } } : primary.capabilities ? { capabilities: { ...primary.capabilities, coldArchival: false } } : {},
+    async get(vault, collection, id) {
+      const s = storeFor(vault, collection);
+      const result = await s.get(vault, collection, id);
+      if (result === null && opts.age && !isInternal(collection)) {
+        if (!opts.age.collections?.length || opts.age.collections.includes(collection)) {
+          return opts.age.cold.get(vault, collection, id);
+        }
+      }
+      return result;
+    },
+    async put(vault, collection, id, envelope, expectedVersion) {
+      const rn = routeNameFor(vault, collection);
+      if (maybeQueueWrite(rn, "put", vault, collection, id, envelope, expectedVersion)) return;
+      if (isBlobChunks(collection) && tieredBlobs) {
+        const dataSize = envelope._data.length;
+        const s2 = blobStoreForSize(dataSize);
+        return s2.put(vault, collection, id, envelope, expectedVersion);
+      }
+      const s = storeFor(vault, collection);
+      if (opts.age && !isInternal(collection)) {
+        opts.age.cold.delete(vault, collection, id).catch(() => {
+        });
+      }
+      return s.put(vault, collection, id, envelope, expectedVersion);
+    },
+    async delete(vault, collection, id) {
+      const rn = routeNameFor(vault, collection);
+      if (maybeQueueWrite(rn, "delete", vault, collection, id)) return;
+      const s = storeFor(vault, collection);
+      await s.delete(vault, collection, id);
+      if (opts.age && !isInternal(collection)) {
+        await opts.age.cold.delete(vault, collection, id).catch(() => {
+        });
+      }
+    },
+    async list(vault, collection) {
+      const s = storeFor(vault, collection);
+      const ids = await s.list(vault, collection);
+      if (opts.age && !isInternal(collection)) {
+        if (!opts.age.collections?.length || opts.age.collections.includes(collection)) {
+          const coldIds = await opts.age.cold.list(vault, collection).catch(() => []);
+          if (coldIds.length > 0) {
+            const merged = new Set(ids);
+            for (const id of coldIds) merged.add(id);
+            return [...merged];
+          }
+        }
+      }
+      return ids;
+    },
+    async loadAll(vault) {
+      const stores = getStoresForVault(vault);
+      const snapshots = await Promise.all(
+        stores.map((s) => s.loadAll(vault).catch(() => ({})))
+      );
+      return mergeSnapshots(snapshots);
+    },
+    async saveAll(vault, data) {
+      const partitioned = /* @__PURE__ */ new Map();
+      for (const [collection, records] of Object.entries(data)) {
+        const s = storeFor(vault, collection);
+        if (!partitioned.has(s)) partitioned.set(s, {});
+        partitioned.get(s)[collection] = records;
+      }
+      await Promise.all(
+        [...partitioned.entries()].map(([s, snap]) => s.saveAll(vault, snap))
+      );
+    },
+    async compact(vault, compactOpts) {
+      if (!opts.age) return 0;
+      let migrated = 0;
+      const collections = opts.age.collections?.length ? opts.age.collections : Object.keys(await primary.loadAll(vault).catch(() => ({})));
+      for (const collection of collections) {
+        const ids = await primary.list(vault, collection).catch(() => []);
+        for (const id of ids) {
+          const envelope = await primary.get(vault, collection, id);
+          if (!envelope) continue;
+          if (isCold(collection, envelope, compactOpts?.before)) {
+            await opts.age.cold.put(vault, collection, id, envelope);
+            await primary.delete(vault, collection, id);
+            migrated++;
+          }
+        }
+      }
+      return migrated;
+    },
+    // ── Runtime override / suspend ──────────────────────
+    override(route, overrideStore, overrideOpts) {
+      if (overrideOpts?.hydrate) {
+        return (async () => {
+          overrides.set(route, overrideStore);
+        })();
+      }
+      overrides.set(route, overrideStore);
+    },
+    clearOverride(route) {
+      overrides.delete(route);
+    },
+    suspend(route, suspendOpts) {
+      suspended.add(route);
+      if (suspendOpts?.queue) {
+        writeQueues.set(route, {
+          writes: [],
+          maxSize: suspendOpts.maxQueueSize ?? 1e4
+        });
+      }
+    },
+    async resume(route) {
+      suspended.delete(route);
+      const queue = writeQueues.get(route);
+      if (!queue || queue.writes.length === 0) {
+        writeQueues.delete(route);
+        return 0;
+      }
+      let replayed = 0;
+      const target = overrides.get(route) ?? resolveOriginalStore(route);
+      for (const write of queue.writes) {
+        try {
+          if (write.method === "put" && write.envelope) {
+            await target.put(write.vault, write.collection, write.id, write.envelope, write.expectedVersion);
+          } else if (write.method === "delete") {
+            await target.delete(write.vault, write.collection, write.id);
+          }
+          replayed++;
+        } catch {
+        }
+      }
+      writeQueues.delete(route);
+      return replayed;
+    },
+    routeStatus() {
+      const ov = {};
+      for (const [k, v] of overrides) ov[k] = v.name ?? "unnamed";
+      const q = {};
+      for (const [k, v] of writeQueues) q[k] = v.writes.length;
+      return { overrides: ov, suspended: [...suspended], queued: q };
+    },
+    resolveBackend(vaultId) {
+      if (opts.vaultRoutes) {
+        for (const [prefix, s] of Object.entries(opts.vaultRoutes)) {
+          if (vaultId.startsWith(prefix)) return s;
+        }
+      }
+      return primary;
+    }
+  };
+  if (anyHas("listVaults")) {
+    store.listVaults = async () => {
+      const results = await Promise.all(
+        [...allStores].filter((s) => s.listVaults !== void 0).map((s) => s.listVaults().catch(() => []))
+      );
+      return [...new Set(results.flat())];
+    };
+  }
+  if (anyHas("ping")) {
+    store.ping = async () => {
+      const results = await Promise.all(
+        [...allStores].filter((s) => s.ping !== void 0).map((s) => s.ping().catch(() => false))
+      );
+      return results.some(Boolean);
+    };
+  }
+  return store;
+  function buildName() {
+    const names = [...allStores].map((s) => s.name ?? "?").join("+");
+    return `route(${names})`;
+  }
+  function anyHas(method) {
+    return [...allStores].some((s) => s[method]);
+  }
+  function getStoresForVault(vault) {
+    const stores = /* @__PURE__ */ new Set();
+    if (opts.vaultRoutes) {
+      for (const [prefix, s] of Object.entries(opts.vaultRoutes)) {
+        if (vault.startsWith(prefix)) {
+          stores.add(s);
+          return [...stores];
+        }
+      }
+    }
+    stores.add(primary);
+    if (simpleBlobStore) stores.add(simpleBlobStore);
+    if (tieredBlobs?.large) stores.add(tieredBlobs.large);
+    if (tieredBlobs?.small && tieredBlobs.small !== primary) stores.add(tieredBlobs.small);
+    if (opts.age?.cold) stores.add(opts.age.cold);
+    if (opts.routes) {
+      for (const s of Object.values(opts.routes)) stores.add(s);
+    }
+    return [...stores];
+  }
+}
+function mergeSnapshots(snapshots) {
+  const merged = {};
+  for (const snap of snapshots) {
+    for (const [collection, records] of Object.entries(snap)) {
+      if (!merged[collection]) {
+        merged[collection] = { ...records };
+        continue;
+      }
+      for (const [id, envelope] of Object.entries(records)) {
+        const existing = merged[collection][id];
+        if (!existing || envelope._ts >= existing._ts) {
+          merged[collection][id] = envelope;
+        }
+      }
+    }
+  }
+  return merged;
+}
+
+// src/with-store/store-middleware.ts
+function wrapStore(store, ...middlewares) {
+  let result = store;
+  for (let i = middlewares.length - 1; i >= 0; i--) {
+    result = middlewares[i](result);
+  }
+  return result;
+}
+function withRetry(opts = {}) {
+  const maxRetries = opts.maxRetries ?? 3;
+  const backoffMs = opts.backoffMs ?? 500;
+  const jitter = opts.jitter ?? 0.3;
+  const retryOn = opts.retryOn ? new Set(opts.retryOn) : null;
+  function shouldRetry(err) {
+    if (!retryOn) return true;
+    if (err && typeof err === "object" && "code" in err) {
+      return retryOn.has(err.code);
+    }
+    return true;
+  }
+  async function retryable(fn) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (attempt >= maxRetries || !shouldRetry(err)) throw err;
+        const delay = backoffMs * Math.pow(2, attempt) * (1 + Math.random() * jitter);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+    throw lastError;
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `retry(${next.name})` : "retry",
+    get: (v, c, id) => retryable(() => next.get(v, c, id)),
+    put: (v, c, id, env, ev) => retryable(() => next.put(v, c, id, env, ev)),
+    delete: (v, c, id) => retryable(() => next.delete(v, c, id)),
+    list: (v, c) => retryable(() => next.list(v, c)),
+    loadAll: (v) => retryable(() => next.loadAll(v)),
+    saveAll: (v, d) => retryable(() => next.saveAll(v, d))
+  });
+}
+var LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+function withLogging(opts = {}) {
+  const minLevel = LOG_LEVELS[opts.level ?? "info"];
+  const logger = opts.logger ?? console;
+  const logData = opts.logData ?? false;
+  function log(level, method, args, durationMs) {
+    if (LOG_LEVELS[level] < minLevel) return;
+    const parts = [`[noydb:${method}]`, ...Object.entries(args).map(([k, v]) => `${k}=${String(v)}`)];
+    if (durationMs !== void 0) parts.push(`${durationMs}ms`);
+    logger[level](parts.join(" "));
+  }
+  function timed(method, args, fn) {
+    const start = Date.now();
+    return fn().then(
+      (result) => {
+        log("debug", method, args, Date.now() - start);
+        return result;
+      },
+      (err) => {
+        log("error", method, { ...args, error: err.message }, Date.now() - start);
+        throw err;
+      }
+    );
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `log(${next.name})` : "log",
+    get: (v, c, id) => timed("get", { vault: v, collection: c, id }, () => next.get(v, c, id)),
+    put: (v, c, id, env, ev) => timed("put", {
+      vault: v,
+      collection: c,
+      id,
+      version: env._v,
+      ...logData ? { data: env._data.slice(0, 40) + "..." } : {}
+    }, () => next.put(v, c, id, env, ev)),
+    delete: (v, c, id) => timed("delete", { vault: v, collection: c, id }, () => next.delete(v, c, id)),
+    list: (v, c) => timed("list", { vault: v, collection: c }, () => next.list(v, c)),
+    loadAll: (v) => timed("loadAll", { vault: v }, () => next.loadAll(v)),
+    saveAll: (v, d) => timed("saveAll", { vault: v }, () => next.saveAll(v, d))
+  });
+}
+function withMetrics(opts) {
+  function tracked(method, vault, fn, collection, id) {
+    const start = Date.now();
+    return fn().then(
+      (result) => {
+        opts.onOperation({
+          method,
+          vault,
+          ...collection !== void 0 ? { collection } : {},
+          ...id !== void 0 ? { id } : {},
+          durationMs: Date.now() - start,
+          success: true
+        });
+        return result;
+      },
+      (err) => {
+        opts.onOperation({
+          method,
+          vault,
+          ...collection !== void 0 ? { collection } : {},
+          ...id !== void 0 ? { id } : {},
+          durationMs: Date.now() - start,
+          success: false,
+          error: err
+        });
+        throw err;
+      }
+    );
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `metrics(${next.name})` : "metrics",
+    get: (v, c, id) => tracked("get", v, () => next.get(v, c, id), c, id),
+    put: (v, c, id, env, ev) => tracked("put", v, () => next.put(v, c, id, env, ev), c, id),
+    delete: (v, c, id) => tracked("delete", v, () => next.delete(v, c, id), c, id),
+    list: (v, c) => tracked("list", v, () => next.list(v, c), c),
+    loadAll: (v) => tracked("loadAll", v, () => next.loadAll(v)),
+    saveAll: (v, d) => tracked("saveAll", v, () => next.saveAll(v, d))
+  });
+}
+function withCircuitBreaker(opts = {}) {
+  const threshold = opts.failureThreshold ?? 5;
+  const resetMs = opts.resetTimeoutMs ?? 3e4;
+  let state = "closed";
+  let failures = 0;
+  let lastFailureTime = 0;
+  function recordSuccess() {
+    if (state === "half-open") {
+      state = "closed";
+      failures = 0;
+      opts.onClose?.();
+    }
+    failures = 0;
+  }
+  function recordFailure() {
+    failures++;
+    lastFailureTime = Date.now();
+    if (failures >= threshold && state === "closed") {
+      state = "open";
+      opts.onOpen?.();
+    }
+  }
+  function canAttempt() {
+    if (state === "closed") return true;
+    if (state === "open") {
+      if (Date.now() - lastFailureTime >= resetMs) {
+        state = "half-open";
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  async function guarded(fn, fallback) {
+    if (!canAttempt()) return fallback;
+    try {
+      const result = await fn();
+      recordSuccess();
+      return result;
+    } catch (err) {
+      recordFailure();
+      throw err;
+    }
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `cb(${next.name})` : "cb",
+    get: (v, c, id) => guarded(() => next.get(v, c, id), null),
+    put: (v, c, id, env, ev) => guarded(() => next.put(v, c, id, env, ev), void 0),
+    delete: (v, c, id) => guarded(() => next.delete(v, c, id), void 0),
+    list: (v, c) => guarded(() => next.list(v, c), []),
+    loadAll: (v) => guarded(() => next.loadAll(v), {}),
+    saveAll: (v, d) => guarded(() => next.saveAll(v, d), void 0)
+  });
+}
+function withCache(opts = {}) {
+  const maxEntries = opts.maxEntries ?? 500;
+  const ttlMs = opts.ttlMs ?? 6e4;
+  const cache = /* @__PURE__ */ new Map();
+  function cacheKey(vault, collection, id) {
+    return `${vault}\0${collection}\0${id}`;
+  }
+  function getFromCache(key) {
+    const entry = cache.get(key);
+    if (!entry) return void 0;
+    if (ttlMs > 0 && Date.now() - entry.cachedAt > ttlMs) {
+      cache.delete(key);
+      return void 0;
+    }
+    cache.delete(key);
+    cache.set(key, entry);
+    return entry.envelope;
+  }
+  function setInCache(key, envelope) {
+    if (cache.size >= maxEntries) {
+      const oldest = cache.keys().next().value;
+      if (oldest !== void 0) cache.delete(oldest);
+    }
+    cache.set(key, { envelope, cachedAt: Date.now() });
+  }
+  function invalidate(key) {
+    cache.delete(key);
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `cache(${next.name})` : "cache",
+    async get(vault, collection, id) {
+      const key = cacheKey(vault, collection, id);
+      const cached = getFromCache(key);
+      if (cached !== void 0) return cached;
+      const result = await next.get(vault, collection, id);
+      setInCache(key, result);
+      return result;
+    },
+    async put(vault, collection, id, env, ev) {
+      invalidate(cacheKey(vault, collection, id));
+      await next.put(vault, collection, id, env, ev);
+      setInCache(cacheKey(vault, collection, id), env);
+    },
+    async delete(vault, collection, id) {
+      invalidate(cacheKey(vault, collection, id));
+      await next.delete(vault, collection, id);
+    },
+    list: (v, c) => next.list(v, c),
+    loadAll: (v) => next.loadAll(v),
+    saveAll: (v, d) => next.saveAll(v, d)
+  });
+}
+function withHealthCheck(opts = {}) {
+  const intervalMs = opts.checkIntervalMs ?? 3e4;
+  const failThreshold = opts.suspendAfterFailures ?? 3;
+  const successThreshold = opts.resumeAfterSuccess ?? 1;
+  let isSuspended = false;
+  let consecutiveFailures = 0;
+  let consecutiveSuccesses = 0;
+  return (next) => {
+    const checkFn = opts.check ?? (next.ping ? () => next.ping() : async () => {
+      await next.list("__health__", "__ping__");
+      return true;
+    });
+    async function doCheck() {
+      try {
+        const ok = await checkFn();
+        if (ok) {
+          consecutiveFailures = 0;
+          consecutiveSuccesses++;
+          if (isSuspended && consecutiveSuccesses >= successThreshold) {
+            isSuspended = false;
+            consecutiveSuccesses = 0;
+            opts.onResume?.();
+          }
+        } else {
+          throw new Error("Health check returned false");
+        }
+      } catch {
+        consecutiveSuccesses = 0;
+        consecutiveFailures++;
+        if (!isSuspended && consecutiveFailures >= failThreshold) {
+          isSuspended = true;
+          consecutiveFailures = 0;
+          opts.onSuspend?.();
+        }
+      }
+    }
+    setInterval(() => {
+      void doCheck();
+    }, intervalMs);
+    const wrapped = {
+      ...next,
+      name: next.name ? `health(${next.name})` : "health",
+      async get(v, c, id) {
+        return isSuspended ? null : next.get(v, c, id);
+      },
+      async put(v, c, id, env, ev) {
+        if (!isSuspended) await next.put(v, c, id, env, ev);
+      },
+      async delete(v, c, id) {
+        if (!isSuspended) await next.delete(v, c, id);
+      },
+      async list(v, c) {
+        return isSuspended ? [] : next.list(v, c);
+      },
+      async loadAll(v) {
+        return isSuspended ? {} : next.loadAll(v);
+      },
+      async saveAll(v, d) {
+        if (!isSuspended) await next.saveAll(v, d);
+      }
+    };
+    return wrapped;
+  };
+}
+
+export {
+  routeStore,
+  wrapStore,
+  withRetry,
+  withLogging,
+  withMetrics,
+  withCircuitBreaker,
+  withCache,
+  withHealthCheck
+};
+//# sourceMappingURL=chunk-EIPVYUEP.js.map