durable-cf-streams 0.1.0

package/dist/chunk-LK4KY5UI.js

@@ -0,0 +1,285 @@
+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/r2.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 R2Store = class {
+  bucket;
+  waiters = /* @__PURE__ */ new Map();
+  streamCache = /* @__PURE__ */ new Map();
+  constructor(bucket) {
+    this.bucket = bucket;
+  }
+  metaKey(path) {
+    return `stream/${path}/meta.json`;
+  }
+  dataKey(path) {
+    return `stream/${path}/data`;
+  }
+  async getMetadata(path) {
+    const obj = await this.bucket.get(this.metaKey(path));
+    if (!obj) {
+      return null;
+    }
+    const text = await obj.text();
+    return JSON.parse(text);
+  }
+  async getData(path) {
+    const obj = await this.bucket.get(this.dataKey(path));
+    if (!obj) {
+      return new Uint8Array(0);
+    }
+    const buffer = await obj.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  async put(path, options) {
+    const existingMeta = await this.getMetadata(path);
+    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.bucket.put(this.metaKey(path), JSON.stringify(meta), {
+        httpMetadata: { contentType: "application/json" }
+      }),
+      this.bucket.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.getMetadata(path);
+    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 existingData = await this.getData(path);
+    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.bucket.put(this.metaKey(path), JSON.stringify(updatedMeta), {
+        httpMetadata: { contentType: "application/json" }
+      }),
+      this.bucket.put(this.dataKey(path), newData)
+    ]);
+    this.notifyWaiters(path, newData);
+    return { nextOffset };
+  }
+  async get(path, options) {
+    const meta = await this.getMetadata(path);
+    if (!meta) {
+      this.streamCache.delete(path);
+      throw new StreamNotFoundError(path);
+    }
+    this.streamCache.set(path, { contentType: meta.contentType });
+    const data = await this.getData(path);
+    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.getMetadata(path);
+    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.bucket.delete(this.metaKey(path)),
+      this.bucket.delete(this.dataKey(path))
+    ]);
+  }
+  has(path) {
+    return this.streamCache.has(path);
+  }
+  async waitForData(path, offset, timeoutMs) {
+    const meta = await this.getMetadata(path);
+    if (!meta) {
+      throw new StreamNotFoundError(path);
+    }
+    const data = await this.getData(path);
+    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 {
+  R2Store
+};