@loro-dev/flock-sqlite 0.1.0

package/src/digest.ts

@@ -0,0 +1,259 @@
+import type { EntryClock, MetadataMap, Value } from "./types";
+
+const TAG_RAW_VALUE = 0x10;
+const TAG_RAW_CLOCK = 0x11;
+const TAG_RAW_METADATA = 0x12;
+const TAG_JSON_NULL = 0x20;
+const TAG_JSON_BOOL = 0x21;
+const TAG_JSON_NUMBER = 0x22;
+const TAG_JSON_STRING = 0x23;
+const TAG_JSON_ARRAY = 0x24;
+const TAG_JSON_OBJECT = 0x25;
+
+type RawValue = {
+  data?: Value;
+  metadata?: MetadataMap;
+  clock: EntryClock;
+};
+
+export type DigestRow = {
+  key: Uint8Array;
+  data: string | null;
+  metadata: string | null;
+  physical: number;
+  logical: number;
+  peer: string;
+};
+
+const textEncoder = new TextEncoder();
+
+function toHex(bytes: Uint8Array): string {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+function encodeU64(value: number | bigint): Uint8Array {
+  let remaining = BigInt(value);
+  const out: number[] = [];
+  do {
+    let byte = Number(remaining & 0x7fn);
+    remaining >>= 7n;
+    if (remaining !== 0n) {
+      byte |= 0x80;
+    }
+    out.push(byte);
+  } while (remaining !== 0n);
+  return new Uint8Array(out);
+}
+
+function encodeI64(value: number | bigint): Uint8Array {
+  let remaining = BigInt(value);
+  const out: number[] = [];
+  let more = true;
+  while (more) {
+    let byte = Number(remaining & 0x7fn);
+    remaining >>= 7n;
+    const signBitSet = (byte & 0x40) !== 0;
+    if (
+      (remaining === 0n && !signBitSet) ||
+      (remaining === -1n && signBitSet)
+    ) {
+      more = false;
+    } else {
+      byte |= 0x80;
+    }
+    out.push(byte);
+  }
+  return new Uint8Array(out);
+}
+
+export async function sha256(bytes: Uint8Array): Promise<Uint8Array> {
+  const cryptoMaybe = typeof crypto !== "undefined" ? crypto : undefined;
+  if (cryptoMaybe?.subtle) {
+    const digestInput = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(digestInput).set(bytes);
+    const digest = await cryptoMaybe.subtle.digest("SHA-256", digestInput);
+    return new Uint8Array(digest);
+  }
+  try {
+    const { createHash } = await import("crypto");
+    const hash = createHash("sha256");
+    hash.update(bytes);
+    return new Uint8Array(hash.digest());
+  } catch {
+    throw new Error("No crypto implementation available for digest");
+  }
+}
+
+class DigestWriter {
+  private chunks: number[] = [];
+
+  writeTag(tag: number): void {
+    this.chunks.push(tag & 0xff);
+  }
+
+  writeBool(value: boolean): void {
+    this.chunks.push(value ? 1 : 0);
+  }
+
+  writeBytes(bytes: Uint8Array): void {
+    this.writeLen(bytes.length);
+    for (let i = 0; i < bytes.length; i += 1) {
+      this.chunks.push(bytes[i]);
+    }
+  }
+
+  writeRawBytes(bytes: Uint8Array): void {
+    for (let i = 0; i < bytes.length; i += 1) {
+      this.chunks.push(bytes[i]);
+    }
+  }
+
+  writeLen(length: number): void {
+    this.writeRawBytes(encodeU64(length));
+  }
+
+  writeI64(value: number): void {
+    this.writeRawBytes(encodeI64(value));
+  }
+
+  writeF64(value: number): void {
+    const view = new DataView(new ArrayBuffer(8));
+    view.setFloat64(0, value, false);
+    const bytes = new Uint8Array(view.buffer);
+    this.writeRawBytes(bytes);
+  }
+
+  writeString(value: string): void {
+    this.writeBytes(textEncoder.encode(value));
+  }
+
+  writeJson(value: Value): void {
+    if (value === null) {
+      this.writeTag(TAG_JSON_NULL);
+      return;
+    }
+    if (typeof value === "boolean") {
+      this.writeTag(TAG_JSON_BOOL);
+      this.writeBool(value);
+      return;
+    }
+    if (typeof value === "number") {
+      this.writeTag(TAG_JSON_NUMBER);
+      this.writeF64(value);
+      return;
+    }
+    if (typeof value === "string") {
+      this.writeTag(TAG_JSON_STRING);
+      this.writeString(value);
+      return;
+    }
+    if (Array.isArray(value)) {
+      this.writeTag(TAG_JSON_ARRAY);
+      this.writeLen(value.length);
+      for (const entry of value) {
+        this.writeJson(entry);
+      }
+      return;
+    }
+    if (value && typeof value === "object") {
+      const entries = Object.entries(value as Record<string, Value>).sort(
+        ([a], [b]) => (a < b ? -1 : a > b ? 1 : 0),
+      );
+      this.writeTag(TAG_JSON_OBJECT);
+      this.writeLen(entries.length);
+      for (const [name, entry] of entries) {
+        this.writeString(name);
+        this.writeJson(entry);
+      }
+      return;
+    }
+    throw new TypeError("Unsupported JSON value in digest");
+  }
+
+  writeRawValue(value: RawValue): void {
+    this.writeTag(TAG_RAW_VALUE);
+    if (value.data === undefined) {
+      this.writeBool(false);
+    } else {
+      this.writeBool(true);
+      this.writeJson(value.data);
+    }
+    this.writeTag(TAG_RAW_METADATA);
+    if (!value.metadata || typeof value.metadata !== "object") {
+      this.writeBool(false);
+    } else {
+      const entries = Object.entries(value.metadata).sort(
+        ([a], [b]) => (a < b ? -1 : a > b ? 1 : 0),
+      );
+      this.writeBool(true);
+      this.writeLen(entries.length);
+      for (const [name, entry] of entries) {
+        this.writeString(name);
+        this.writeJson(entry as Value);
+      }
+    }
+    this.writeTag(TAG_RAW_CLOCK);
+    this.writeF64(value.clock.physicalTime);
+    this.writeI64(Math.trunc(value.clock.logicalCounter));
+    this.writeBytes(textEncoder.encode(value.clock.peerId));
+  }
+
+  async finish(): Promise<Uint8Array> {
+    const data = new Uint8Array(this.chunks);
+    return sha256(data);
+  }
+}
+
+function parseMetadata(json: string | null): MetadataMap | undefined {
+  if (!json) return undefined;
+  try {
+    const value = JSON.parse(json);
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return undefined;
+    }
+    return value as MetadataMap;
+  } catch {
+    return undefined;
+  }
+}
+
+function parseData(json: string | null): Value | undefined {
+  if (json === null || json === undefined) {
+    return undefined;
+  }
+  return JSON.parse(json) as Value;
+}
+
+async function digestEntry(row: DigestRow): Promise<Uint8Array | null> {
+  const data = parseData(row.data);
+  if (data === undefined) {
+    return null;
+  }
+  const metadata = parseMetadata(row.metadata);
+  const writer = new DigestWriter();
+  writer.writeBytes(row.key);
+  writer.writeRawValue({
+    data,
+    metadata,
+    clock: {
+      physicalTime: Number(row.physical),
+      logicalCounter: Number(row.logical),
+      peerId: String(row.peer),
+    },
+  });
+  return writer.finish();
+}
+
+export async function computeDigest(rows: DigestRow[]): Promise<string> {
+  const acc = new Uint8Array(32);
+  for (const row of rows) {
+    const digest = await digestEntry(row);
+    if (!digest) {
+      continue;
+    }
+    for (let i = 0; i < acc.length; i += 1) {
+      acc[i] ^= digest[i];
+    }
+  }
+  return toHex(acc);
+}