@evolu/common 5.4.8 → 6.0.0

package/src/Config.ts

@@ -1,119 +0,0 @@
-import * as Context from "effect/Context";
-import * as Layer from "effect/Layer";
-import * as LogLevel from "effect/LogLevel";
-import * as Logger from "effect/Logger";
-import * as ManagedRuntime from "effect/ManagedRuntime";
-import * as Match from "effect/Match";
-
-export interface Config {
-  /**
-   * URL to reload browser tabs after {@link Owner} reset or restore.
-   *
-   * The default value is `/`.
-   */
-  reloadUrl: string;
-
-  /**
-   * URL for Evolu sync and backup server.
-   *
-   * The default value is `https://evolu.world`.
-   */
-  syncUrl: string;
-
-  /**
-   * Evolu is multitenant - it can run more instances concurrently. Every Evolu
-   * instance has to have its own unique name. Database files are separated and
-   * invisible to each other.
-   *
-   * The default value is: `Evolu`.
-   */
-  name: string;
-
-  /**
-   * Maximum physical clock drift allowed in ms.
-   *
-   * The default value is 5 * 60 * 1000 (5 minutes).
-   */
-  maxDrift: number;
-
-  /**
-   * Setting the minimum log level. The default value is `none`.
-   *
-   * For development, use `trace` to log all events and `debug` to log only
-   * events with values. For production, use `warning`.
-   */
-  minimumLogLevel: "none" | "trace" | "debug" | "warning";
-
-  /**
-   * Enables websocket connection
-   *
-   * If set to true runs a websocket connection on the sync url
-   */
-  enableWebsocketConnection?: true;
-
-  /**
-   * Allows to reuse websocket connections for multiple database setup
-   *
-   * Works INSTEAD of enableWebsocket and if set overrides enableWebsocket this
-   * attaches the database to a connection produced by a call back from another
-   * database that has enableWebsocketConnection
-   */
-  externalWebsocketConnection?: WebSocket;
-}
-
-export const Config = Context.GenericTag<Config>("Config");
-
-export const defaultConfig: Config = {
-  reloadUrl: "/",
-  syncUrl: "https://evolu.world",
-  name: "Evolu",
-  maxDrift: 5 * 60 * 1000,
-  minimumLogLevel: "none",
-};
-
-/** https://effect.website/docs/guides/runtime */
-export const createRuntime = (
-  partialConfig?: Partial<Config>,
-): ManagedRuntime.ManagedRuntime<Config, never> => {
-  const config = { ...defaultConfig, ...partialConfig };
-  const ConfigLive = Layer.succeed(Config, config);
-
-  const minimumLogLevel = Match.value(config.minimumLogLevel).pipe(
-    Match.when("debug", () => LogLevel.Debug),
-    Match.when("none", () => LogLevel.None),
-    Match.when("trace", () => LogLevel.Trace),
-    Match.when("warning", () => LogLevel.Warning),
-    Match.exhaustive,
-  );
-
-  const evoluLayer =
-    config.minimumLogLevel === "none"
-      ? ConfigLive
-      : Layer.mergeAll(
-          ConfigLive,
-          Logger.minimumLogLevel(minimumLogLevel),
-          Logger.replace(Logger.defaultLogger, makeEvoluLogger(config.name)),
-        );
-
-  return ManagedRuntime.make(evoluLayer);
-};
-
-// TODO: Spans and Effect native variadic log args.
-const makeEvoluLogger = (name: string) =>
-  Logger.make(({ logLevel, message, date }) => {
-    const fn =
-      logLevel._tag === "Warning"
-        ? "warn"
-        : logLevel._tag === "Error"
-          ? "error"
-          : "log";
-
-    const hours = date.getHours().toString().padStart(2, "0");
-    const minutes = date.getMinutes().toString().padStart(2, "0");
-    const seconds = date.getSeconds().toString().padStart(2, "0");
-    const milliseconds = date.getMilliseconds().toString().padStart(3, "0");
-    const formattedDate = `${hours}:${minutes}:${seconds}:${milliseconds}`;
-
-    const messages: unknown[] = Array.isArray(message) ? message : [message];
-    globalThis.console[fn](`${formattedDate} [${name}]`, ...messages);
-  });

package/src/Crdt.ts

@@ -1,361 +0,0 @@
-import * as S from "@effect/schema/Schema";
-import * as Arr from "effect/Array";
-import * as Brand from "effect/Brand";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Either from "effect/Either";
-import { pipe } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Number from "effect/Number";
-import * as Option from "effect/Option";
-import * as String from "effect/String";
-import { Config } from "./Config.js";
-import { NanoIdGenerator, NodeId } from "./Crypto.js";
-import { murmurhash } from "./Murmurhash.js";
-
-// https://sergeiturukin.com/2017/06/26/hybrid-logical-clocks.html
-// https://muratbuffalo.blogspot.com/2014/07/hybrid-logical-clocks.html
-// https://jaredforsyth.com/posts/hybrid-logical-clocks/
-// https://github.com/clintharris/crdt-example-app_annotated/blob/master/shared/timestamp.js
-
-export interface Timestamp {
-  readonly node: NodeId;
-  readonly millis: Millis;
-  readonly counter: Counter;
-}
-
-export const AllowedTimeRange = {
-  greaterThan: 860934419999,
-  lessThan: 2582803260000,
-};
-
-/**
- * Millis represents a time that is valid for usage with the Merkle tree. It
- * must be between Apr 13, 1997, and Nov 05, 2051, to ensure MinutesBase3 length
- * equals 16. We can find diff for two Merkle trees only within this range. If
- * the device clock is out of range, Evolu will not store data until it's
- * fixed.
- */
-export const Millis = S.Number.pipe(
-  S.greaterThan(AllowedTimeRange.greaterThan),
-  S.lessThan(AllowedTimeRange.lessThan),
-  S.brand("Millis"),
-);
-
-export type Millis = typeof Millis.Type;
-
-export const initialMillis = S.decodeSync(Millis)(
-  AllowedTimeRange.greaterThan + 1,
-);
-
-export const Counter = S.Number.pipe(S.between(0, 65535), S.brand("Counter"));
-export type Counter = typeof Counter.Type;
-
-const initialCounter = S.decodeSync(Counter)(0);
-
-export type TimestampHash = number & Brand.Brand<"TimestampHash">;
-
-export type TimestampString = string & Brand.Brand<"TimestampString">;
-
-export const timestampToString = (t: Timestamp): TimestampString =>
-  [
-    new Date(t.millis).toISOString(),
-    t.counter.toString(16).toUpperCase().padStart(4, "0"),
-    t.node,
-  ].join("-") as TimestampString;
-
-export const unsafeTimestampFromString = (s: TimestampString): Timestamp => {
-  const a = s.split("-");
-  return {
-    millis: Date.parse(a.slice(0, 3).join("-")).valueOf() as Millis,
-    counter: parseInt(a[3], 16) as Counter,
-    node: a[4] as NodeId,
-  };
-};
-
-export const timestampToHash = (t: Timestamp): TimestampHash =>
-  murmurhash(timestampToString(t)) as TimestampHash;
-
-const syncNodeId = S.decodeSync(NodeId)("0000000000000000");
-
-export const makeSyncTimestamp = (
-  millis: Millis = initialMillis,
-): Timestamp => ({
-  millis,
-  counter: initialCounter,
-  node: syncNodeId,
-});
-
-export const makeInitialTimestamp = NanoIdGenerator.pipe(
-  Effect.flatMap(({ nodeId }) => nodeId),
-  Effect.map(
-    (node): Timestamp => ({
-      millis: initialMillis,
-      counter: initialCounter,
-      node,
-    }),
-  ),
-);
-
-export class Time extends Context.Tag("Time")<
-  Time,
-  {
-    readonly now: Effect.Effect<Millis, TimestampTimeOutOfRangeError>;
-  }
->() {
-  static Live = Layer.succeed(Time, {
-    now: Effect.suspend(() => S.decode(Millis)(Date.now())).pipe(
-      Effect.catchTag("ParseError", () =>
-        Effect.fail<TimestampTimeOutOfRangeError>({
-          _tag: "TimestampTimeOutOfRangeError",
-        }),
-      ),
-    ),
-  });
-}
-
-/**
- * The TimestampError type represents all Timestamp-related errors. If such an
- * error happens, the device clock is skewed and should be set to the current
- * time.
- */
-export type TimestampError =
-  | TimestampDriftError
-  | TimestampCounterOverflowError
-  | TimestampDuplicateNodeError
-  | TimestampTimeOutOfRangeError;
-
-export interface TimestampDriftError {
-  readonly _tag: "TimestampDriftError";
-  readonly next: Millis;
-  readonly now: Millis;
-}
-
-export interface TimestampCounterOverflowError {
-  readonly _tag: "TimestampCounterOverflowError";
-}
-
-export interface TimestampDuplicateNodeError {
-  readonly _tag: "TimestampDuplicateNodeError";
-  readonly node: NodeId;
-}
-
-export interface TimestampTimeOutOfRangeError {
-  readonly _tag: "TimestampTimeOutOfRangeError";
-}
-
-const getNextMillis = (millis: ReadonlyArray<Millis>) =>
-  Effect.gen(function* () {
-    const time = yield* Time;
-    const config = yield* Config;
-
-    const now = yield* time.now;
-    const next = Math.max(now, ...millis) as Millis;
-
-    if (next - now > config.maxDrift)
-      yield* Effect.fail<TimestampDriftError>({
-        _tag: "TimestampDriftError",
-        now,
-        next,
-      });
-
-    return next;
-  });
-
-const incrementCounter = (counter: Counter) =>
-  pipe(
-    Number.increment(counter),
-    S.decodeEither(Counter),
-    Either.mapLeft(
-      (): TimestampCounterOverflowError => ({
-        _tag: "TimestampCounterOverflowError",
-      }),
-    ),
-  );
-
-const counterMin = S.decodeSync(Counter)(0);
-
-export const sendTimestamp = (
-  timestamp: Timestamp,
-): Effect.Effect<
-  Timestamp,
-  | TimestampDriftError
-  | TimestampCounterOverflowError
-  | TimestampTimeOutOfRangeError,
-  Time | Config
-> =>
-  Effect.gen(function* () {
-    const millis = yield* getNextMillis([timestamp.millis]);
-    const counter =
-      millis === timestamp.millis
-        ? yield* incrementCounter(timestamp.counter)
-        : counterMin;
-    return { ...timestamp, millis, counter };
-  });
-
-export const receiveTimestamp = ({
-  local,
-  remote,
-}: {
-  readonly local: Timestamp;
-  readonly remote: Timestamp;
-}): Effect.Effect<
-  Timestamp,
-  | TimestampDriftError
-  | TimestampCounterOverflowError
-  | TimestampDuplicateNodeError
-  | TimestampTimeOutOfRangeError,
-  Time | Config
-> =>
-  Effect.gen(function* (_) {
-    if (local.node === remote.node)
-      yield* Effect.fail<TimestampDuplicateNodeError>({
-        _tag: "TimestampDuplicateNodeError",
-        node: local.node,
-      });
-
-    const millis = yield* getNextMillis([local.millis, remote.millis]);
-    const counter = yield* millis === local.millis && millis === remote.millis
-      ? incrementCounter(Math.max(local.counter, remote.counter) as Counter)
-      : millis === local.millis
-        ? incrementCounter(local.counter)
-        : millis === remote.millis
-          ? incrementCounter(remote.counter)
-          : Either.right(counterMin);
-
-    return { ...local, millis, counter };
-  });
-
-/**
- * It's actually not Merkle Tree but a Merkleized prefix tree, aka Merkle Trie.
- * https://decomposition.al/blog/2019/05/31/how-i-learned-about-merklix-trees-without-having-to-become-a-cryptocurrency-enthusiast
- */
-export interface MerkleTree {
-  readonly hash?: TimestampHash;
-  readonly "0"?: MerkleTree;
-  readonly "1"?: MerkleTree;
-  readonly "2"?: MerkleTree;
-}
-
-export type MerkleTreeString = string & Brand.Brand<"MerkleTreeString">;
-
-export const initialMerkleTree = Object.create(null) as MerkleTree;
-
-type MerkleTreeKey = keyof Omit<MerkleTree, "hash">;
-
-type MerkleTreePath = ReadonlyArray<MerkleTreeKey>;
-
-export const millisToMerkleTreePath = (millis: Millis): MerkleTreePath =>
-  Math.floor(millis / 1000 / 60)
-    .toString(3)
-    .split("") as MerkleTreePath;
-
-const merkleTreePathToMillis = (path: MerkleTreePath) =>
-  path.length === 0
-    ? initialMillis
-    : // 16 is the length of the base 3 value of the current time in minutes.
-      // Ensure it's padded to create the full value.
-      ((parseInt(path.join("").padEnd(16, "0"), 3) * 1000 * 60) as Millis);
-
-const xorTimestampHashes = (a: TimestampHash | undefined, b: TimestampHash) =>
-  ((a || 0) ^ b) as TimestampHash;
-
-const insertKey = (
-  tree: MerkleTree,
-  path: MerkleTreePath,
-  hash: TimestampHash,
-): MerkleTree => {
-  if (path.length === 0) return tree;
-  const key = path[0];
-  const child = tree[key] || {};
-  return {
-    ...tree,
-    [key]: {
-      ...child,
-      ...insertKey(child, path.slice(1), hash),
-      hash: xorTimestampHashes(child.hash, hash),
-    },
-  };
-};
-
-export const insertIntoMerkleTree = (
-  tree: MerkleTree,
-  timestamp: Timestamp,
-): MerkleTree => {
-  const path = millisToMerkleTreePath(timestamp.millis);
-  const hash = timestampToHash(timestamp);
-  return insertKey(
-    { ...tree, hash: xorTimestampHashes(tree.hash, hash) },
-    path,
-    hash,
-  );
-};
-
-const sortedMerkleTreeKeys: ReadonlyArray<MerkleTreeKey> = ["0", "1", "2"];
-
-const getSortedMerkleTreeKeys = (tree: MerkleTree) =>
-  sortedMerkleTreeKeys.filter((key) => key in tree);
-
-export const diffMerkleTrees = (
-  tree1: MerkleTree,
-  tree2: MerkleTree,
-): Option.Option<Millis> => {
-  if (tree1.hash === tree2.hash) return Option.none();
-  let node1 = tree1;
-  let node2 = tree2;
-  let diffPath: MerkleTreePath = [];
-
-  // This loop will eventually stop when it traverses down to find
-  // where the hashes differ, or otherwise when there are no leaves
-  // left (this shouldn't happen, if that's the case the hash check at
-  // the top of this function should pass)
-  // eslint-disable-next-line no-constant-condition
-  while (1) {
-    const keys = Arr.dedupeWith(
-      getSortedMerkleTreeKeys(node1).concat(getSortedMerkleTreeKeys(node2)),
-      String.Equivalence,
-    );
-    let diffKey: MerkleTreeKey | null = null;
-
-    // Traverse down the trie through keys that are different. We
-    // traverse down the keys in order. Stop in two cases: either one
-    // of the nodes doesn't have the key or a different key isn't
-    // found. For the former case, we have to do that because pruning is
-    // lossy. We don't know if we've pruned off a changed key, so we
-    // can't traverse down anymore. For the latter case, it means two
-    // things: either we've hit the bottom of the tree, or the changed
-    // key has been pruned off. In the latter case, we have a "partial"
-    // key and will fill the rest with 0s. If multiple older
-    // messages were added into one trie, we might likely
-    // generate a time that only encompasses *some* of those
-    // messages. Pruning is lossy, and we traverse down the left-most
-    // changed time that we know of, because of pruning, it might take
-    // multiple passes to sync up a trie.
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      const next1 = node1[key];
-      const next2 = node2[key];
-      if (!next1 || !next2) break;
-      if (next1.hash !== next2.hash) {
-        diffKey = key;
-        break;
-      }
-    }
-
-    if (!diffKey) {
-      return Option.some(merkleTreePathToMillis(diffPath));
-    }
-
-    diffPath = [...diffPath, diffKey];
-    node1 = node1[diffKey] || initialMerkleTree;
-    node2 = node2[diffKey] || initialMerkleTree;
-  }
-
-  return Option.none();
-};
-
-export const merkleTreeToString = (m: MerkleTree): MerkleTreeString =>
-  JSON.stringify(m) as MerkleTreeString;
-
-export const unsafeMerkleTreeFromString = (m: MerkleTreeString): MerkleTree =>
-  JSON.parse(m) as MerkleTree;