@tungthedev/streams-server 0.2.0

package/src/util/stream_paths.ts

@@ -0,0 +1,50 @@
+import { createHash } from "node:crypto";
+
+export function streamHash16Hex(stream: string): string {
+  const full = createHash("sha256").update(stream).digest();
+  return full.subarray(0, 16).toString("hex"); // 32 hex chars
+}
+
+export function pad16(n: number): string {
+  const s = String(n);
+  return s.padStart(16, "0");
+}
+
+export function segmentObjectKey(streamHash: string, segmentIndex: number): string {
+  return `streams/${streamHash}/segments/${pad16(segmentIndex)}.bin`;
+}
+
+export function manifestObjectKey(streamHash: string): string {
+  return `streams/${streamHash}/manifest.json`;
+}
+
+export function schemaObjectKey(streamHash: string): string {
+  return `streams/${streamHash}/schema-registry.json`;
+}
+
+export function indexRunObjectKey(streamHash: string, runId: string): string {
+  return `streams/${streamHash}/index/${runId}.idx`;
+}
+
+export function secondaryIndexRunObjectKey(streamHash: string, indexName: string, runId: string): string {
+  return `streams/${streamHash}/secondary-index/${encodeURIComponent(indexName)}/${runId}.idx`;
+}
+
+export function lexiconRunObjectKey(
+  streamHash: string,
+  sourceKind: string,
+  sourceName: string,
+  runId: string
+): string {
+  const encodedKind = encodeURIComponent(sourceKind);
+  const encodedName = encodeURIComponent(sourceName === "" ? "__default__" : sourceName);
+  return `streams/${streamHash}/lexicon/${encodedKind}/${encodedName}/${runId}.lex`;
+}
+
+export function searchCompanionObjectKey(streamHash: string, segmentIndex: number, objectId: string): string {
+  return `streams/${streamHash}/segments/${pad16(segmentIndex)}-${objectId}.cix`;
+}
+
+export function localSegmentPath(rootDir: string, streamHash: string, segmentIndex: number): string {
+  return `${rootDir}/local/streams/${streamHash}/segments/${pad16(segmentIndex)}.bin`;
+}

package/src/util/time.ts

@@ -0,0 +1,14 @@
+import { Result } from "better-result";
+
+export function parseTimestampMsResult(input: string): Result<bigint, { kind: "empty_timestamp" | "invalid_timestamp"; message: string }> {
+  const s = input.trim();
+  if (s === "") return Result.err({ kind: "empty_timestamp", message: "empty timestamp" });
+  // unix nanos
+  if (/^[0-9]+$/.test(s)) {
+    return Result.ok(BigInt(s) / 1_000_000n);
+  }
+  const d = new Date(s);
+  const ms = d.getTime();
+  if (Number.isNaN(ms)) return Result.err({ kind: "invalid_timestamp", message: `invalid timestamp: ${input}` });
+  return Result.ok(BigInt(ms));
+}

package/src/util/yield.ts

@@ -0,0 +1,3 @@
+export async function yieldToEventLoop(): Promise<void> {
+  await new Promise<void>((resolve) => setTimeout(resolve, 0));
+}

package/src/util/zstd.ts

@@ -0,0 +1,24 @@
+import * as zlib from "node:zlib";
+import { dsError } from "./ds_error.ts";
+
+type ZstdOperation = (bytes: Uint8Array) => Uint8Array | Buffer;
+
+function getZstdOperation(name: "zstdCompressSync" | "zstdDecompressSync") {
+  const operation = (zlib as Record<string, unknown>)[name];
+
+  if (typeof operation !== "function") {
+    throw dsError(
+      `${name} is not available in this runtime. Prisma Streams local requires node:zlib zstd support.`,
+    );
+  }
+
+  return operation as ZstdOperation;
+}
+
+export function zstdCompressSync(bytes: Uint8Array) {
+  return getZstdOperation("zstdCompressSync")(bytes);
+}
+
+export function zstdDecompressSync(bytes: Uint8Array) {
+  return getZstdOperation("zstdDecompressSync")(bytes);
+}