@valentinkolb/sync 2.2.0 → 3.0.0

package/browser/store.js

@@ -0,0 +1,61 @@
+// src/browser/store.ts
+class MemoryStore {
+  data = new Map;
+  timers = new Map;
+  get(key) {
+    const entry = this.data.get(key);
+    if (!entry)
+      return;
+    if (entry.expiresAt !== null && Date.now() >= entry.expiresAt) {
+      this.del(key);
+      return;
+    }
+    return entry.value;
+  }
+  set(key, value, ttlMs) {
+    const existingTimer = this.timers.get(key);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+      this.timers.delete(key);
+    }
+    const expiresAt = ttlMs != null && ttlMs > 0 ? Date.now() + ttlMs : null;
+    this.data.set(key, { value, expiresAt });
+    if (ttlMs != null && ttlMs > 0) {
+      this.timers.set(key, setTimeout(() => this.del(key), ttlMs));
+    }
+  }
+  del(key) {
+    this.data.delete(key);
+    const timer = this.timers.get(key);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(key);
+    }
+  }
+  keys(prefix) {
+    const now = Date.now();
+    const result = [];
+    for (const [key, entry] of this.data) {
+      if (entry.expiresAt !== null && now >= entry.expiresAt) {
+        this.del(key);
+        continue;
+      }
+      if (prefix === undefined || key.startsWith(prefix)) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+  clear() {
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+    this.data.clear();
+  }
+}
+var createMemoryStore = () => new MemoryStore;
+export {
+  createMemoryStore,
+  MemoryStore
+};

package/browser/topic.js

@@ -0,0 +1,359 @@
+// src/browser/store.ts
+class MemoryStore {
+  data = new Map;
+  timers = new Map;
+  get(key) {
+    const entry = this.data.get(key);
+    if (!entry)
+      return;
+    if (entry.expiresAt !== null && Date.now() >= entry.expiresAt) {
+      this.del(key);
+      return;
+    }
+    return entry.value;
+  }
+  set(key, value, ttlMs) {
+    const existingTimer = this.timers.get(key);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+      this.timers.delete(key);
+    }
+    const expiresAt = ttlMs != null && ttlMs > 0 ? Date.now() + ttlMs : null;
+    this.data.set(key, { value, expiresAt });
+    if (ttlMs != null && ttlMs > 0) {
+      this.timers.set(key, setTimeout(() => this.del(key), ttlMs));
+    }
+  }
+  del(key) {
+    this.data.delete(key);
+    const timer = this.timers.get(key);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(key);
+    }
+  }
+  keys(prefix) {
+    const now = Date.now();
+    const result = [];
+    for (const [key, entry] of this.data) {
+      if (entry.expiresAt !== null && now >= entry.expiresAt) {
+        this.del(key);
+        continue;
+      }
+      if (prefix === undefined || key.startsWith(prefix)) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+  clear() {
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+    this.data.clear();
+  }
+}
+var createMemoryStore = () => new MemoryStore;
+
+// src/browser/internal/emitter.ts
+class Emitter {
+  listeners = new Set;
+  on(fn) {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+  emit(value) {
+    for (const fn of this.listeners) {
+      fn(value);
+    }
+  }
+  once() {
+    return new Promise((resolve) => {
+      const unsub = this.on((value) => {
+        unsub();
+        resolve(value);
+      });
+    });
+  }
+  onceWithSignal(signal) {
+    if (!signal)
+      return this.once();
+    if (signal.aborted)
+      return Promise.reject(Object.assign(new Error("aborted"), { name: "AbortError" }));
+    return new Promise((resolve, reject) => {
+      const unsub = this.on((value) => {
+        unsub();
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      });
+      const onAbort = () => {
+        unsub();
+        signal.removeEventListener("abort", onAbort);
+        reject(Object.assign(new Error("aborted"), { name: "AbortError" }));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+}
+
+// src/browser/internal/event-log.ts
+class EventLog {
+  entries = [];
+  seq = 0;
+  emitter = new Emitter;
+  maxLen;
+  retentionMs;
+  constructor(config = {}) {
+    this.maxLen = config.maxLen ?? 50000;
+    this.retentionMs = config.retentionMs ?? 5 * 60 * 1000;
+  }
+  append(fields) {
+    const id = String(++this.seq);
+    const entry = { id, ts: Date.now(), fields };
+    this.entries.push(entry);
+    this.trim();
+    this.emitter.emit(entry);
+    return id;
+  }
+  range(after, count) {
+    const afterNum = Number(after) || 0;
+    const result = [];
+    for (const entry of this.entries) {
+      if (Number(entry.id) <= afterNum)
+        continue;
+      result.push(entry);
+      if (count !== undefined && result.length >= count)
+        break;
+    }
+    return result;
+  }
+  latest() {
+    if (this.entries.length === 0)
+      return "0";
+    return this.entries[this.entries.length - 1].id;
+  }
+  earliest() {
+    if (this.entries.length === 0)
+      return null;
+    return this.entries[0].id;
+  }
+  has(cursor) {
+    const num = Number(cursor);
+    return this.entries.some((e) => Number(e.id) === num);
+  }
+  async* subscribe(after, signal) {
+    let cursor = after;
+    while (!signal?.aborted) {
+      const buffered = this.range(cursor);
+      if (buffered.length > 0) {
+        for (const entry of buffered) {
+          cursor = entry.id;
+          yield entry;
+        }
+        continue;
+      }
+      try {
+        const entry = await this.emitter.onceWithSignal(signal);
+        if (Number(entry.id) > Number(cursor)) {
+          cursor = entry.id;
+          yield entry;
+        }
+      } catch {
+        break;
+      }
+    }
+  }
+  trim() {
+    if (this.entries.length > this.maxLen) {
+      this.entries.splice(0, this.entries.length - this.maxLen);
+    }
+    if (this.retentionMs > 0) {
+      const cutoff = Date.now() - this.retentionMs;
+      let trimCount = 0;
+      for (const entry of this.entries) {
+        if (entry.ts >= cutoff)
+          break;
+        trimCount++;
+      }
+      if (trimCount > 0) {
+        this.entries.splice(0, trimCount);
+      }
+    }
+  }
+  get size() {
+    return this.entries.length;
+  }
+}
+
+// src/browser/internal/id.ts
+var randomId = () => crypto.randomUUID();
+
+// src/browser/topic.ts
+var DEFAULT_PREFIX = "sync:topic";
+var DEFAULT_TENANT = "default";
+var DEFAULT_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+var DEFAULT_IDEMPOTENCY_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+var DEFAULT_PAYLOAD_BYTES = 128 * 1024;
+var DEFAULT_TIMEOUT_MS = 30000;
+var textEncoder = new TextEncoder;
+var topic = (config) => {
+  const prefix = config.prefix ?? DEFAULT_PREFIX;
+  const defaultTenant = config.tenantId ?? DEFAULT_TENANT;
+  const retentionMs = config.retentionMs ?? DEFAULT_RETENTION_MS;
+  const maxPayloadBytes = config.limits?.payloadBytes ?? DEFAULT_PAYLOAD_BYTES;
+  const store = config.store ?? createMemoryStore();
+  const resolveTenant = (tenantId) => tenantId ?? defaultTenant;
+  const eventLogs = new Map;
+  const getEventLog = (tenantId) => {
+    const key = `${prefix}:${tenantId}:${config.id}`;
+    let log = eventLogs.get(key);
+    if (!log) {
+      log = new EventLog({ retentionMs });
+      eventLogs.set(key, log);
+    }
+    return log;
+  };
+  const idempotencyKey = (tenantId, key) => `${prefix}:${tenantId}:${config.id}:idempotency:${key}`;
+  const parsePayload = (entry) => {
+    const rawPayload = entry.fields.payload;
+    if (typeof rawPayload !== "string")
+      return null;
+    try {
+      return JSON.parse(rawPayload);
+    } catch {
+      return null;
+    }
+  };
+  const pub = async (pubCfg) => {
+    const tenantId = resolveTenant(pubCfg.tenantId);
+    const log = getEventLog(tenantId);
+    const parsed = config.schema.safeParse(pubCfg.data);
+    if (!parsed.success)
+      throw parsed.error;
+    const payload = {
+      data: parsed.data,
+      orderingKey: pubCfg.orderingKey,
+      meta: pubCfg.meta,
+      publishedAt: Date.now()
+    };
+    const payloadRaw = JSON.stringify(payload);
+    const payloadBytes = textEncoder.encode(payloadRaw).byteLength;
+    if (payloadBytes > maxPayloadBytes) {
+      throw new Error(`payload exceeds limit (${maxPayloadBytes} bytes)`);
+    }
+    if (pubCfg.idempotencyKey) {
+      const idemKey = idempotencyKey(tenantId, pubCfg.idempotencyKey);
+      const existing = store.get(idemKey);
+      if (existing) {
+        return { eventId: existing, cursor: existing };
+      }
+      const eventId2 = log.append({ payload: payloadRaw });
+      store.set(idemKey, eventId2, pubCfg.idempotencyTtlMs ?? DEFAULT_IDEMPOTENCY_TTL_MS);
+      return { eventId: eventId2, cursor: eventId2 };
+    }
+    const eventId = log.append({ payload: payloadRaw });
+    return { eventId, cursor: eventId };
+  };
+  const reader = (group = "default") => {
+    const consumerId = `consumer:${randomId()}`;
+    let cursor = "0";
+    const recv = async (recvCfg = {}) => {
+      const tenantId = resolveTenant(recvCfg.tenantId);
+      const log = getEventLog(tenantId);
+      const wait = recvCfg.wait ?? true;
+      const timeoutMs = recvCfg.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+      const entries = log.range(cursor, 1);
+      if (entries.length > 0) {
+        return deliverEntry(entries[0], log, tenantId);
+      }
+      if (!wait)
+        return null;
+      const ac = new AbortController;
+      const timeout = setTimeout(() => ac.abort(), timeoutMs);
+      const onUserAbort = () => ac.abort();
+      if (recvCfg.signal)
+        recvCfg.signal.addEventListener("abort", onUserAbort, { once: true });
+      try {
+        for await (const entry of log.subscribe(cursor, ac.signal)) {
+          clearTimeout(timeout);
+          if (recvCfg.signal)
+            recvCfg.signal.removeEventListener("abort", onUserAbort);
+          return deliverEntry(entry, log, tenantId);
+        }
+      } catch {} finally {
+        clearTimeout(timeout);
+        if (recvCfg.signal)
+          recvCfg.signal.removeEventListener("abort", onUserAbort);
+      }
+      return null;
+    };
+    const deliverEntry = (entry, _log, _tenantId) => {
+      const stored = parsePayload(entry);
+      if (!stored) {
+        cursor = entry.id;
+        return null;
+      }
+      const parsed = config.schema.safeParse(stored.data);
+      if (!parsed.success) {
+        cursor = entry.id;
+        return null;
+      }
+      cursor = entry.id;
+      const commit = async () => {
+        return true;
+      };
+      return {
+        data: parsed.data,
+        eventId: entry.id,
+        cursor: entry.id,
+        deliveryId: `${group}:${entry.id}`,
+        orderingKey: stored.orderingKey,
+        publishedAt: stored.publishedAt,
+        meta: stored.meta,
+        commit
+      };
+    };
+    const stream = async function* (streamCfg = {}) {
+      const wait = streamCfg.wait ?? true;
+      while (!streamCfg.signal?.aborted) {
+        const message = await recv(streamCfg);
+        if (message) {
+          yield message;
+          continue;
+        }
+        if (!wait)
+          break;
+      }
+    };
+    return { group, recv, stream };
+  };
+  const live = async function* (liveCfg = {}) {
+    const tenantId = resolveTenant(liveCfg.tenantId);
+    const log = getEventLog(tenantId);
+    let cursor = liveCfg.after ?? log.latest();
+    for await (const entry of log.subscribe(cursor, liveCfg.signal)) {
+      const stored = parsePayload(entry);
+      if (!stored)
+        continue;
+      const parsed = config.schema.safeParse(stored.data);
+      if (!parsed.success)
+        continue;
+      cursor = entry.id;
+      yield {
+        data: parsed.data,
+        eventId: entry.id,
+        cursor: entry.id,
+        orderingKey: stored.orderingKey,
+        publishedAt: stored.publishedAt,
+        meta: stored.meta
+      };
+    }
+  };
+  return { pub, reader, live };
+};
+export {
+  topic
+};