durable-cf-streams 0.1.0

package/dist/chunk-E7XMLPFW.js

@@ -0,0 +1,275 @@
+import {
+  Deferred_exports,
+  Effect_exports
+} from "./chunk-VLDLQ6TP.js";
+import {
+  ContentTypeMismatchError,
+  SequenceConflictError,
+  StreamConflictError,
+  StreamNotFoundError,
+  formatJsonResponse,
+  formatOffset,
+  generateCursor,
+  generateETag,
+  initialOffset,
+  isJsonContentType,
+  normalizeContentType,
+  offsetToBytePos,
+  processJsonAppend,
+  validateJsonCreate
+} from "./chunk-5N2UNHIW.js";
+
+// src/storage/d1.ts
+function validateIdempotentCreate(existing, options) {
+  const existingNormalized = normalizeContentType(existing.contentType);
+  const reqNormalized = normalizeContentType(options.contentType);
+  if (existingNormalized !== reqNormalized) {
+    throw new ContentTypeMismatchError(existingNormalized, reqNormalized);
+  }
+  if (options.ttlSeconds !== existing.ttlSeconds) {
+    throw new StreamConflictError("TTL mismatch on idempotent create");
+  }
+  if (options.expiresAt !== existing.expiresAt) {
+    throw new StreamConflictError("Expires-At mismatch on idempotent create");
+  }
+}
+function prepareInitialData(options) {
+  let data = options.data ?? new Uint8Array(0);
+  const isJson = isJsonContentType(options.contentType);
+  if (isJson && data.length > 0) {
+    data = validateJsonCreate(data, true);
+  }
+  const appendCount = data.length > 0 ? 1 : 0;
+  const nextOffset = formatOffset(appendCount, data.length);
+  return { data, appendCount, nextOffset };
+}
+var D1Store = class _D1Store {
+  db;
+  waiters = /* @__PURE__ */ new Map();
+  streamCache = /* @__PURE__ */ new Map();
+  constructor(db) {
+    this.db = db;
+  }
+  static schema = "CREATE TABLE IF NOT EXISTS streams (path TEXT PRIMARY KEY, content_type TEXT NOT NULL, ttl_seconds INTEGER, expires_at TEXT, created_at INTEGER NOT NULL, data BLOB NOT NULL DEFAULT x'', next_offset TEXT NOT NULL, last_seq TEXT, append_count INTEGER NOT NULL DEFAULT 0);";
+  async initialize() {
+    await this.db.exec(_D1Store.schema);
+  }
+  async put(path, options) {
+    const existing = await this.db.prepare(
+      "SELECT content_type, ttl_seconds, expires_at, next_offset FROM streams WHERE path = ?"
+    ).bind(path).first();
+    if (existing) {
+      validateIdempotentCreate(
+        {
+          contentType: existing.content_type,
+          ttlSeconds: existing.ttl_seconds ?? void 0,
+          expiresAt: existing.expires_at ?? void 0
+        },
+        options
+      );
+      return { created: false, nextOffset: existing.next_offset };
+    }
+    const { data, appendCount, nextOffset } = prepareInitialData(options);
+    await this.db.prepare(`
+        INSERT INTO streams (path, content_type, ttl_seconds, expires_at, created_at, data, next_offset, append_count)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `).bind(
+      path,
+      options.contentType,
+      options.ttlSeconds ?? null,
+      options.expiresAt ?? null,
+      Date.now(),
+      data,
+      nextOffset,
+      appendCount
+    ).run();
+    this.streamCache.set(path, { contentType: options.contentType });
+    return { created: true, nextOffset };
+  }
+  async append(path, data, options) {
+    const stream = await this.db.prepare(
+      "SELECT content_type, data, next_offset, last_seq, append_count FROM streams WHERE path = ?"
+    ).bind(path).first();
+    if (!stream) {
+      throw new StreamNotFoundError(path);
+    }
+    const streamNormalized = normalizeContentType(stream.content_type);
+    if (options?.contentType) {
+      const reqNormalized = normalizeContentType(options.contentType);
+      if (streamNormalized !== reqNormalized) {
+        throw new ContentTypeMismatchError(streamNormalized, reqNormalized);
+      }
+    }
+    if (options?.seq !== void 0 && stream.last_seq !== null && options.seq <= stream.last_seq) {
+      throw new SequenceConflictError(`> ${stream.last_seq}`, options.seq);
+    }
+    const existingData = new Uint8Array(stream.data);
+    const isJson = isJsonContentType(stream.content_type);
+    let newData;
+    if (isJson) {
+      newData = processJsonAppend(existingData, data);
+    } else {
+      newData = new Uint8Array(existingData.length + data.length);
+      newData.set(existingData);
+      newData.set(data, existingData.length);
+    }
+    const newAppendCount = stream.append_count + 1;
+    const nextOffset = formatOffset(newAppendCount, newData.length);
+    await this.db.prepare(`
+        UPDATE streams
+        SET data = ?, next_offset = ?, last_seq = ?, append_count = ?
+        WHERE path = ?
+      `).bind(
+      newData,
+      nextOffset,
+      options?.seq ?? stream.last_seq,
+      newAppendCount,
+      path
+    ).run();
+    this.notifyWaiters(path, newData);
+    return { nextOffset };
+  }
+  async get(path, options) {
+    const stream = await this.db.prepare(
+      "SELECT content_type, data, next_offset FROM streams WHERE path = ?"
+    ).bind(path).first();
+    if (!stream) {
+      this.streamCache.delete(path);
+      throw new StreamNotFoundError(path);
+    }
+    this.streamCache.set(path, { contentType: stream.content_type });
+    const startOffset = options?.offset ?? initialOffset();
+    const byteOffset = offsetToBytePos(startOffset);
+    const data = new Uint8Array(stream.data);
+    const messages = [];
+    if (byteOffset < data.length) {
+      messages.push({
+        offset: startOffset,
+        timestamp: Date.now(),
+        data: data.slice(byteOffset)
+      });
+    }
+    return {
+      messages,
+      nextOffset: stream.next_offset,
+      upToDate: true,
+      cursor: generateCursor(),
+      etag: generateETag(path, startOffset, stream.next_offset),
+      contentType: stream.content_type
+    };
+  }
+  async head(path) {
+    const stream = await this.db.prepare("SELECT content_type, next_offset FROM streams WHERE path = ?").bind(path).first();
+    if (!stream) {
+      this.streamCache.delete(path);
+      return null;
+    }
+    this.streamCache.set(path, { contentType: stream.content_type });
+    return {
+      contentType: stream.content_type,
+      nextOffset: stream.next_offset,
+      etag: generateETag(path, initialOffset(), stream.next_offset)
+    };
+  }
+  async delete(path) {
+    const waiters = this.waiters.get(path) ?? [];
+    const effect = Effect_exports.forEach(
+      waiters,
+      (waiter) => Deferred_exports.succeed(waiter.deferred, { messages: [], timedOut: false })
+    );
+    Effect_exports.runSync(effect);
+    this.waiters.delete(path);
+    this.streamCache.delete(path);
+    await this.db.prepare("DELETE FROM streams WHERE path = ?").bind(path).run();
+  }
+  has(path) {
+    return this.streamCache.has(path);
+  }
+  async waitForData(path, offset, timeoutMs) {
+    const stream = await this.db.prepare("SELECT data FROM streams WHERE path = ?").bind(path).first();
+    if (!stream) {
+      throw new StreamNotFoundError(path);
+    }
+    const data = new Uint8Array(stream.data);
+    const byteOffset = offsetToBytePos(offset);
+    if (byteOffset < data.length) {
+      return {
+        messages: [
+          { offset, timestamp: Date.now(), data: data.slice(byteOffset) }
+        ],
+        timedOut: false
+      };
+    }
+    const effect = Effect_exports.gen(this, function* () {
+      const deferred = yield* Deferred_exports.make();
+      const waiter = { deferred, offset };
+      const pathWaiters = this.waiters.get(path) ?? [];
+      pathWaiters.push(waiter);
+      this.waiters.set(path, pathWaiters);
+      const timeout = Effect_exports.as(
+        Effect_exports.delay(
+          Effect_exports.sync(() => {
+          }),
+          timeoutMs
+        ),
+        { messages: [], timedOut: true }
+      );
+      const result = yield* Effect_exports.race(Deferred_exports.await(deferred), timeout);
+      const currentWaiters = this.waiters.get(path) ?? [];
+      const index = currentWaiters.indexOf(waiter);
+      if (index !== -1) {
+        currentWaiters.splice(index, 1);
+      }
+      return result;
+    });
+    return Effect_exports.runPromise(effect);
+  }
+  formatResponse(path, messages) {
+    const cached = this.streamCache.get(path);
+    if (!cached) {
+      return new Uint8Array(0);
+    }
+    if (messages.length === 0) {
+      const isJson2 = isJsonContentType(cached.contentType);
+      return isJson2 ? new TextEncoder().encode("[]") : new Uint8Array(0);
+    }
+    const combined = new Uint8Array(
+      messages.reduce((acc, m) => acc + m.data.length, 0)
+    );
+    let offset = 0;
+    for (const message of messages) {
+      combined.set(message.data, offset);
+      offset += message.data.length;
+    }
+    const isJson = isJsonContentType(cached.contentType);
+    return isJson ? formatJsonResponse(combined) : combined;
+  }
+  notifyWaiters(path, data) {
+    const waiters = this.waiters.get(path) ?? [];
+    this.waiters.set(path, []);
+    const effect = Effect_exports.forEach(waiters, (waiter) => {
+      const byteOffset = offsetToBytePos(waiter.offset);
+      if (byteOffset < data.length) {
+        return Deferred_exports.succeed(waiter.deferred, {
+          messages: [
+            {
+              offset: waiter.offset,
+              timestamp: Date.now(),
+              data: data.slice(byteOffset)
+            }
+          ],
+          timedOut: false
+        });
+      }
+      const remaining = this.waiters.get(path) ?? [];
+      remaining.push(waiter);
+      this.waiters.set(path, remaining);
+      return Effect_exports.void;
+    });
+    Effect_exports.runSync(effect);
+  }
+};
+
+export {
+  D1Store
+};

package/dist/chunk-KHGAPSJ7.js

@@ -0,0 +1,271 @@
+import {
+  Deferred_exports,
+  Effect_exports
+} from "./chunk-VLDLQ6TP.js";
+import {
+  ContentTypeMismatchError,
+  SequenceConflictError,
+  StreamConflictError,
+  StreamNotFoundError,
+  formatJsonResponse,
+  formatOffset,
+  generateCursor,
+  generateETag,
+  initialOffset,
+  isJsonContentType,
+  normalizeContentType,
+  offsetToBytePos,
+  processJsonAppend,
+  validateJsonCreate
+} from "./chunk-5N2UNHIW.js";
+
+// src/storage/kv.ts
+function validateIdempotentCreate(existing, options) {
+  const existingNormalized = normalizeContentType(existing.contentType);
+  const reqNormalized = normalizeContentType(options.contentType);
+  if (existingNormalized !== reqNormalized) {
+    throw new ContentTypeMismatchError(existingNormalized, reqNormalized);
+  }
+  if (options.ttlSeconds !== existing.ttlSeconds) {
+    throw new StreamConflictError("TTL mismatch on idempotent create");
+  }
+  if (options.expiresAt !== existing.expiresAt) {
+    throw new StreamConflictError("Expires-At mismatch on idempotent create");
+  }
+}
+function prepareInitialData(options) {
+  let data = options.data ?? new Uint8Array(0);
+  const isJson = isJsonContentType(options.contentType);
+  if (isJson && data.length > 0) {
+    data = validateJsonCreate(data, true);
+  }
+  const appendCount = data.length > 0 ? 1 : 0;
+  const nextOffset = formatOffset(appendCount, data.length);
+  return { data, appendCount, nextOffset };
+}
+var KVStore = class {
+  kv;
+  waiters = /* @__PURE__ */ new Map();
+  streamCache = /* @__PURE__ */ new Map();
+  constructor(kv) {
+    this.kv = kv;
+  }
+  metaKey(path) {
+    return `stream:${path}:meta`;
+  }
+  dataKey(path) {
+    return `stream:${path}:data`;
+  }
+  async put(path, options) {
+    const existingMeta = await this.kv.get(
+      this.metaKey(path),
+      "json"
+    );
+    if (existingMeta) {
+      validateIdempotentCreate(existingMeta, options);
+      return { created: false, nextOffset: existingMeta.nextOffset };
+    }
+    const { data, appendCount, nextOffset } = prepareInitialData(options);
+    const meta = {
+      contentType: options.contentType,
+      ttlSeconds: options.ttlSeconds,
+      expiresAt: options.expiresAt,
+      createdAt: Date.now(),
+      nextOffset,
+      appendCount
+    };
+    await Promise.all([
+      this.kv.put(this.metaKey(path), JSON.stringify(meta)),
+      this.kv.put(this.dataKey(path), data)
+    ]);
+    this.streamCache.set(path, { contentType: options.contentType });
+    return { created: true, nextOffset };
+  }
+  async append(path, data, options) {
+    const meta = await this.kv.get(this.metaKey(path), "json");
+    if (!meta) {
+      throw new StreamNotFoundError(path);
+    }
+    const streamNormalized = normalizeContentType(meta.contentType);
+    if (options?.contentType) {
+      const reqNormalized = normalizeContentType(options.contentType);
+      if (streamNormalized !== reqNormalized) {
+        throw new ContentTypeMismatchError(streamNormalized, reqNormalized);
+      }
+    }
+    if (options?.seq !== void 0 && meta.lastSeq !== void 0 && options.seq <= meta.lastSeq) {
+      throw new SequenceConflictError(`> ${meta.lastSeq}`, options.seq);
+    }
+    const existingRaw = await this.kv.get(this.dataKey(path), "arrayBuffer");
+    const existingData = existingRaw ? new Uint8Array(existingRaw) : new Uint8Array(0);
+    const isJson = isJsonContentType(meta.contentType);
+    let newData;
+    if (isJson) {
+      newData = processJsonAppend(existingData, data);
+    } else {
+      newData = new Uint8Array(existingData.length + data.length);
+      newData.set(existingData);
+      newData.set(data, existingData.length);
+    }
+    const newAppendCount = meta.appendCount + 1;
+    const nextOffset = formatOffset(newAppendCount, newData.length);
+    const updatedMeta = {
+      ...meta,
+      nextOffset,
+      lastSeq: options?.seq ?? meta.lastSeq,
+      appendCount: newAppendCount
+    };
+    await Promise.all([
+      this.kv.put(this.metaKey(path), JSON.stringify(updatedMeta)),
+      this.kv.put(this.dataKey(path), newData)
+    ]);
+    this.notifyWaiters(path, newData);
+    return { nextOffset };
+  }
+  async get(path, options) {
+    const meta = await this.kv.get(this.metaKey(path), "json");
+    if (!meta) {
+      this.streamCache.delete(path);
+      throw new StreamNotFoundError(path);
+    }
+    this.streamCache.set(path, { contentType: meta.contentType });
+    const raw = await this.kv.get(this.dataKey(path), "arrayBuffer");
+    const data = raw ? new Uint8Array(raw) : new Uint8Array(0);
+    const startOffset = options?.offset ?? initialOffset();
+    const byteOffset = offsetToBytePos(startOffset);
+    const messages = [];
+    if (byteOffset < data.length) {
+      messages.push({
+        offset: startOffset,
+        timestamp: Date.now(),
+        data: data.slice(byteOffset)
+      });
+    }
+    return {
+      messages,
+      nextOffset: meta.nextOffset,
+      upToDate: true,
+      cursor: generateCursor(),
+      etag: generateETag(path, startOffset, meta.nextOffset),
+      contentType: meta.contentType
+    };
+  }
+  async head(path) {
+    const meta = await this.kv.get(this.metaKey(path), "json");
+    if (!meta) {
+      this.streamCache.delete(path);
+      return null;
+    }
+    this.streamCache.set(path, { contentType: meta.contentType });
+    return {
+      contentType: meta.contentType,
+      nextOffset: meta.nextOffset,
+      etag: generateETag(path, initialOffset(), meta.nextOffset)
+    };
+  }
+  async delete(path) {
+    const waiters = this.waiters.get(path) ?? [];
+    const effect = Effect_exports.forEach(
+      waiters,
+      (waiter) => Deferred_exports.succeed(waiter.deferred, { messages: [], timedOut: false })
+    );
+    Effect_exports.runSync(effect);
+    this.waiters.delete(path);
+    this.streamCache.delete(path);
+    await Promise.all([
+      this.kv.delete(this.metaKey(path)),
+      this.kv.delete(this.dataKey(path))
+    ]);
+  }
+  has(path) {
+    return this.streamCache.has(path);
+  }
+  async waitForData(path, offset, timeoutMs) {
+    const meta = await this.kv.get(this.metaKey(path), "json");
+    if (!meta) {
+      throw new StreamNotFoundError(path);
+    }
+    const raw = await this.kv.get(this.dataKey(path), "arrayBuffer");
+    const data = raw ? new Uint8Array(raw) : new Uint8Array(0);
+    const byteOffset = offsetToBytePos(offset);
+    if (byteOffset < data.length) {
+      return {
+        messages: [
+          { offset, timestamp: Date.now(), data: data.slice(byteOffset) }
+        ],
+        timedOut: false
+      };
+    }
+    const effect = Effect_exports.gen(this, function* () {
+      const deferred = yield* Deferred_exports.make();
+      const waiter = { deferred, offset };
+      const pathWaiters = this.waiters.get(path) ?? [];
+      pathWaiters.push(waiter);
+      this.waiters.set(path, pathWaiters);
+      const timeout = Effect_exports.as(
+        Effect_exports.delay(
+          Effect_exports.sync(() => {
+          }),
+          timeoutMs
+        ),
+        { messages: [], timedOut: true }
+      );
+      const result = yield* Effect_exports.race(Deferred_exports.await(deferred), timeout);
+      const currentWaiters = this.waiters.get(path) ?? [];
+      const index = currentWaiters.indexOf(waiter);
+      if (index !== -1) {
+        currentWaiters.splice(index, 1);
+      }
+      return result;
+    });
+    return Effect_exports.runPromise(effect);
+  }
+  formatResponse(path, messages) {
+    const cached = this.streamCache.get(path);
+    if (!cached) {
+      return new Uint8Array(0);
+    }
+    if (messages.length === 0) {
+      const isJson2 = isJsonContentType(cached.contentType);
+      return isJson2 ? new TextEncoder().encode("[]") : new Uint8Array(0);
+    }
+    const combined = new Uint8Array(
+      messages.reduce((acc, m) => acc + m.data.length, 0)
+    );
+    let pos = 0;
+    for (const message of messages) {
+      combined.set(message.data, pos);
+      pos += message.data.length;
+    }
+    const isJson = isJsonContentType(cached.contentType);
+    return isJson ? formatJsonResponse(combined) : combined;
+  }
+  notifyWaiters(path, data) {
+    const waiters = this.waiters.get(path) ?? [];
+    this.waiters.set(path, []);
+    const effect = Effect_exports.forEach(waiters, (waiter) => {
+      const byteOffset = offsetToBytePos(waiter.offset);
+      if (byteOffset < data.length) {
+        return Deferred_exports.succeed(waiter.deferred, {
+          messages: [
+            {
+              offset: waiter.offset,
+              timestamp: Date.now(),
+              data: data.slice(byteOffset)
+            }
+          ],
+          timedOut: false
+        });
+      }
+      const remaining = this.waiters.get(path) ?? [];
+      remaining.push(waiter);
+      this.waiters.set(path, remaining);
+      return Effect_exports.void;
+    });
+    Effect_exports.runSync(effect);
+  }
+};
+
+export {
+  KVStore
+};