@valentinkolb/sync 2.2.0 → 3.0.0

package/browser/mutex.js

@@ -0,0 +1,165 @@
+// 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/sleep.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/browser/internal/id.ts
+var randomHex = (bytes) => {
+  const buf = new Uint8Array(bytes);
+  crypto.getRandomValues(buf);
+  return Array.from(buf, (b) => b.toString(16).padStart(2, "0")).join("");
+};
+var simpleHash = (str) => {
+  let hash = 5381;
+  for (let i = 0;i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i) | 0;
+  }
+  return `hash:${(hash >>> 0).toString(16)}`;
+};
+
+// src/browser/mutex.ts
+var DEFAULT_PREFIX = "sync:mutex";
+var DEFAULT_RETRY_COUNT = 10;
+var DEFAULT_RETRY_DELAY = 200;
+var DEFAULT_TTL = 1e4;
+var MAX_RESOURCE_LENGTH = 128;
+var normalizeResource = (resource) => {
+  if (resource.length <= MAX_RESOURCE_LENGTH)
+    return resource;
+  return simpleHash(resource);
+};
+
+class LockError extends Error {
+  resource;
+  constructor(resource) {
+    super(`Failed to acquire lock on resource: ${resource}`);
+    this.name = "LockError";
+    this.resource = resource;
+  }
+}
+var mutex = (config) => {
+  const prefix = config.prefix ?? DEFAULT_PREFIX;
+  const retryCount = config.retryCount ?? DEFAULT_RETRY_COUNT;
+  const retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY;
+  const defaultTtl = config.defaultTtl ?? DEFAULT_TTL;
+  const store = config.store ?? createMemoryStore();
+  const acquire = async (resource, ttl = defaultTtl) => {
+    const safeResource = normalizeResource(resource);
+    const key = `${prefix}:${config.id}:${safeResource}`;
+    const value = randomHex(16);
+    for (let attempt = 0;attempt <= retryCount; attempt++) {
+      const existing = store.get(key);
+      if (existing === undefined) {
+        store.set(key, value, ttl);
+        return {
+          resource: key,
+          value,
+          ttl,
+          expiration: Date.now() + ttl
+        };
+      }
+      if (attempt < retryCount) {
+        await sleep(retryDelay + Math.random() * 100);
+      }
+    }
+    return null;
+  };
+  const release = async (lock) => {
+    const current = store.get(lock.resource);
+    if (current === lock.value) {
+      store.del(lock.resource);
+    }
+  };
+  const extend = async (lock, ttl = defaultTtl) => {
+    const current = store.get(lock.resource);
+    if (current === lock.value) {
+      store.set(lock.resource, lock.value, ttl);
+      lock.ttl = ttl;
+      lock.expiration = Date.now() + ttl;
+      return true;
+    }
+    return false;
+  };
+  const withLock = async (resource, fn, ttl) => {
+    const lock = await acquire(resource, ttl);
+    if (!lock)
+      return null;
+    try {
+      return await fn(lock);
+    } finally {
+      await release(lock);
+    }
+  };
+  const withLockOrThrow = async (resource, fn, ttl) => {
+    const lock = await acquire(resource, ttl);
+    if (!lock) {
+      throw new LockError(resource);
+    }
+    try {
+      return await fn(lock);
+    } finally {
+      await release(lock);
+    }
+  };
+  return { id: config.id, acquire, release, withLock, withLockOrThrow, extend };
+};
+export {
+  mutex,
+  LockError
+};

package/browser/queue.js

@@ -0,0 +1,342 @@
+// 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/id.ts
+var randomId = () => crypto.randomUUID();
+
+// src/browser/internal/sleep.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/browser/queue.ts
+var DAY_MS = 24 * 60 * 60 * 1000;
+var DEFAULT_PREFIX = "sync:queue";
+var DEFAULT_TENANT = "default";
+var DEFAULT_LEASE_MS = 30000;
+var DEFAULT_WAIT_TIMEOUT_MS = 30000;
+var DEFAULT_MAX_DELIVERIES = 10;
+var DEFAULT_MAX_NACK_DELAY_MS = 7 * DAY_MS;
+var DEFAULT_MAX_MESSAGE_AGE_MS = 7 * DAY_MS;
+var DEFAULT_DLQ_RETENTION_MS = 7 * DAY_MS;
+var DEFAULT_IDEMPOTENCY_TTL_MS = 7 * DAY_MS;
+var DEFAULT_PAYLOAD_BYTES = 128 * 1024;
+var DEFAULT_MAINTENANCE_INTERVAL_MS = 1000;
+var textEncoder = new TextEncoder;
+var queue = (config) => {
+  const prefix = config.prefix ?? DEFAULT_PREFIX;
+  const defaultTenant = config.tenantId ?? DEFAULT_TENANT;
+  const defaultLeaseMs = config.delivery?.defaultLeaseMs ?? DEFAULT_LEASE_MS;
+  const maxDeliveries = config.delivery?.maxDeliveries ?? DEFAULT_MAX_DELIVERIES;
+  const maxPayloadBytes = config.limits?.payloadBytes ?? DEFAULT_PAYLOAD_BYTES;
+  const maxNackDelayMs = config.limits?.maxNackDelayMs ?? DEFAULT_MAX_NACK_DELAY_MS;
+  const maxMessageAgeMs = config.limits?.maxMessageAgeMs ?? DEFAULT_MAX_MESSAGE_AGE_MS;
+  const dlqRetentionMs = config.limits?.dlqRetentionMs ?? DEFAULT_DLQ_RETENTION_MS;
+  const resolveTenant = (tenantId) => tenantId ?? defaultTenant;
+  const states = new Map;
+  const getState = (tenantId) => {
+    const key = `${prefix}:${tenantId}:${config.id}`;
+    let state = states.get(key);
+    if (!state) {
+      state = {
+        seq: 0,
+        ready: [],
+        delayed: new Map,
+        messages: new Map,
+        deliveries: new Map,
+        leases: new Map,
+        dlq: new Map,
+        idempotency: new Map,
+        emitter: new Emitter,
+        lastMaintenance: 0
+      };
+      states.set(key, state);
+    }
+    return state;
+  };
+  const runMaintenance = (state) => {
+    const now = Date.now();
+    if (now - state.lastMaintenance < DEFAULT_MAINTENANCE_INTERVAL_MS)
+      return;
+    state.lastMaintenance = now;
+    for (const [messageId, deliverAt] of state.delayed) {
+      if (deliverAt <= now) {
+        state.delayed.delete(messageId);
+        const msg = state.messages.get(messageId);
+        if (msg) {
+          if (now - msg.enqueuedAt > maxMessageAgeMs) {
+            moveToDlq(state, messageId, msg, "expired");
+          } else {
+            state.ready.push(messageId);
+          }
+        }
+      }
+    }
+    for (const [deliveryId, leaseUntil] of state.leases) {
+      if (leaseUntil <= now) {
+        const delivery = state.deliveries.get(deliveryId);
+        state.leases.delete(deliveryId);
+        state.deliveries.delete(deliveryId);
+        if (delivery) {
+          const msg = state.messages.get(delivery.messageId);
+          if (msg) {
+            if (msg.attempt >= maxDeliveries) {
+              moveToDlq(state, delivery.messageId, msg, "max_deliveries");
+            } else {
+              state.ready.push(delivery.messageId);
+              state.emitter.emit();
+            }
+          }
+        }
+      }
+    }
+    for (const [messageId, dlq] of state.dlq) {
+      if (now - dlq.movedAt > dlqRetentionMs) {
+        state.dlq.delete(messageId);
+      }
+    }
+    for (const [key, entry] of state.idempotency) {
+      if (now >= entry.expiresAt) {
+        state.idempotency.delete(key);
+      }
+    }
+  };
+  const moveToDlq = (state, messageId, msg, reason) => {
+    state.dlq.set(messageId, {
+      messageId,
+      data: msg.data,
+      orderingKey: msg.orderingKey,
+      meta: msg.meta,
+      attempts: msg.attempt,
+      movedAt: Date.now(),
+      reason
+    });
+    state.messages.delete(messageId);
+  };
+  const send = async (sendCfg) => {
+    const tenantId = resolveTenant(sendCfg.tenantId);
+    const state = getState(tenantId);
+    const parsed = config.schema.safeParse(sendCfg.data);
+    if (!parsed.success)
+      throw parsed.error;
+    const payloadRaw = JSON.stringify(parsed.data);
+    const payloadBytes = textEncoder.encode(payloadRaw).byteLength;
+    if (payloadBytes > maxPayloadBytes) {
+      throw new Error(`payload exceeds limit (${maxPayloadBytes} bytes)`);
+    }
+    if (sendCfg.idempotencyKey) {
+      const existing = state.idempotency.get(sendCfg.idempotencyKey);
+      if (existing && Date.now() < existing.expiresAt) {
+        return { messageId: existing.messageId };
+      }
+    }
+    const messageId = String(++state.seq);
+    const msg = {
+      data: parsed.data,
+      orderingKey: sendCfg.orderingKey,
+      meta: sendCfg.meta,
+      enqueuedAt: Date.now(),
+      attempt: 0
+    };
+    state.messages.set(messageId, msg);
+    if (sendCfg.idempotencyKey) {
+      state.idempotency.set(sendCfg.idempotencyKey, {
+        messageId,
+        expiresAt: Date.now() + (sendCfg.idempotencyTtlMs ?? DEFAULT_IDEMPOTENCY_TTL_MS)
+      });
+    }
+    const delayMs = sendCfg.delayMs ?? 0;
+    if (delayMs > 0) {
+      state.delayed.set(messageId, Date.now() + delayMs);
+    } else {
+      state.ready.push(messageId);
+      state.emitter.emit();
+    }
+    return { messageId };
+  };
+  const createReader = () => {
+    const recv = async (recvCfg = {}) => {
+      const tenantId = resolveTenant(recvCfg.tenantId);
+      const state = getState(tenantId);
+      const wait = recvCfg.wait ?? true;
+      const timeoutMs = recvCfg.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+      const leaseMs = recvCfg.leaseMs ?? defaultLeaseMs;
+      runMaintenance(state);
+      const claimed = claimNext(state, leaseMs);
+      if (claimed)
+        return claimed;
+      if (!wait)
+        return null;
+      const deadline = Date.now() + timeoutMs;
+      while (!recvCfg.signal?.aborted) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+          break;
+        const raceTimeout = Math.min(remaining, 1000);
+        await Promise.race([
+          state.emitter.onceWithSignal(recvCfg.signal),
+          sleep(raceTimeout)
+        ]).catch(() => {});
+        runMaintenance(state);
+        const claimed2 = claimNext(state, leaseMs);
+        if (claimed2)
+          return claimed2;
+      }
+      return null;
+    };
+    const claimNext = (state, leaseMs) => {
+      while (state.ready.length > 0) {
+        const messageId = state.ready.shift();
+        const msg = state.messages.get(messageId);
+        if (!msg)
+          continue;
+        if (Date.now() - msg.enqueuedAt > maxMessageAgeMs) {
+          moveToDlq(state, messageId, msg, "expired");
+          continue;
+        }
+        msg.attempt++;
+        const deliveryId = `${messageId}:${randomId()}`;
+        const leaseUntil = Date.now() + leaseMs;
+        const delivery = {
+          messageId,
+          deliveryId,
+          leaseUntil,
+          attempt: msg.attempt
+        };
+        state.deliveries.set(deliveryId, delivery);
+        state.leases.set(deliveryId, leaseUntil);
+        return buildReceived(state, messageId, deliveryId, msg, delivery);
+      }
+      return null;
+    };
+    const buildReceived = (state, messageId, deliveryId, msg, delivery) => {
+      const parsed = config.schema.safeParse(msg.data);
+      if (!parsed.success) {
+        state.deliveries.delete(deliveryId);
+        state.leases.delete(deliveryId);
+        state.messages.delete(messageId);
+        return null;
+      }
+      let settled = false;
+      const ack = async () => {
+        if (settled)
+          return false;
+        if (!state.deliveries.has(deliveryId))
+          return false;
+        settled = true;
+        state.deliveries.delete(deliveryId);
+        state.leases.delete(deliveryId);
+        state.messages.delete(messageId);
+        return true;
+      };
+      const nack = async (cfg) => {
+        if (settled)
+          return false;
+        if (!state.deliveries.has(deliveryId))
+          return false;
+        settled = true;
+        state.deliveries.delete(deliveryId);
+        state.leases.delete(deliveryId);
+        if (msg.attempt >= maxDeliveries) {
+          moveToDlq(state, messageId, msg, cfg?.reason ?? "max_deliveries");
+          return true;
+        }
+        const delayMs = cfg?.delayMs ?? 0;
+        if (delayMs > maxNackDelayMs) {
+          throw new Error(`nack delayMs (${delayMs}) exceeds maxNackDelayMs (${maxNackDelayMs})`);
+        }
+        if (delayMs > 0) {
+          state.delayed.set(messageId, Date.now() + delayMs);
+        } else {
+          state.ready.push(messageId);
+          state.emitter.emit();
+        }
+        return true;
+      };
+      const touch = async (cfg) => {
+        if (settled)
+          return false;
+        if (!state.deliveries.has(deliveryId))
+          return false;
+        const newLeaseMs = cfg?.leaseMs ?? defaultLeaseMs;
+        const newLeaseUntil = Date.now() + newLeaseMs;
+        delivery.leaseUntil = newLeaseUntil;
+        state.leases.set(deliveryId, newLeaseUntil);
+        return true;
+      };
+      return {
+        data: parsed.data,
+        messageId,
+        deliveryId,
+        attempt: msg.attempt,
+        leaseUntil: delivery.leaseUntil,
+        orderingKey: msg.orderingKey,
+        meta: msg.meta,
+        ack,
+        nack,
+        touch
+      };
+    };
+    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 { recv, stream };
+  };
+  const defaultReader = createReader();
+  return {
+    send,
+    recv: defaultReader.recv,
+    stream: defaultReader.stream,
+    reader: () => createReader()
+  };
+};
+export {
+  queue
+};

package/browser/ratelimit.js

@@ -0,0 +1,124 @@
+// 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/id.ts
+var simpleHash = (str) => {
+  let hash = 5381;
+  for (let i = 0;i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i) | 0;
+  }
+  return `hash:${(hash >>> 0).toString(16)}`;
+};
+
+// src/browser/ratelimit.ts
+var DEFAULT_PREFIX = "sync:ratelimit";
+var DEFAULT_WINDOW_SECS = 1;
+var MAX_IDENTIFIER_LENGTH = 128;
+var normalizeIdentifier = (identifier) => {
+  if (identifier.length <= MAX_IDENTIFIER_LENGTH)
+    return identifier;
+  return simpleHash(identifier);
+};
+
+class RateLimitError extends Error {
+  remaining;
+  resetIn;
+  constructor(result) {
+    super("Rate limit exceeded");
+    this.name = "RateLimitError";
+    this.remaining = result.remaining;
+    this.resetIn = result.resetIn;
+  }
+}
+var ratelimit = (config) => {
+  const prefix = config.prefix ?? DEFAULT_PREFIX;
+  const windowSecs = config.windowSecs ?? DEFAULT_WINDOW_SECS;
+  const { limit } = config;
+  const store = config.store ?? createMemoryStore();
+  const check = async (identifier) => {
+    const safeIdentifier = normalizeIdentifier(identifier);
+    const now = Date.now();
+    const windowMs = windowSecs * 1000;
+    const currentWindow = Math.floor(now / windowMs);
+    const previousWindow = currentWindow - 1;
+    const elapsedInWindow = now % windowMs;
+    const elapsedRatio = elapsedInWindow / windowMs;
+    const currentKey = `${prefix}:${config.id}:${safeIdentifier}:${currentWindow}`;
+    const previousKey = `${prefix}:${config.id}:${safeIdentifier}:${previousWindow}`;
+    const previousCount = store.get(previousKey) ?? 0;
+    const currentCount = (store.get(currentKey) ?? 0) + 1;
+    store.set(currentKey, currentCount, windowSecs * 2000);
+    const weightedCount = previousCount * (1 - elapsedRatio) + currentCount;
+    const limited = weightedCount > limit;
+    const remaining = Math.max(0, Math.floor(limit - weightedCount));
+    const resetIn = windowMs - elapsedInWindow;
+    return { limited, remaining, resetIn };
+  };
+  const checkOrThrow = async (identifier) => {
+    const result = await check(identifier);
+    if (result.limited) {
+      throw new RateLimitError(result);
+    }
+    return result;
+  };
+  return { id: config.id, check, checkOrThrow };
+};
+export {
+  ratelimit,
+  RateLimitError
+};