@evolu/common 1.0.0

package/src/MerkleTree.ts

@@ -0,0 +1,83 @@
+import { Brand, Option } from "effect";
+import {
+  Millis,
+  Timestamp,
+  TimestampHash,
+  timestampToHash,
+} from "./Timestamp.js";
+
+// Technically, it's not Merkle Tree but “merkleized” prefix tree (trie).
+// https://decomposition.al/blog/2019/05/31/how-i-learned-about-merklix-trees-without-having-to-become-a-cryptocurrency-enthusiast/#fnref:1
+// TODO: Add Schema and use it in Evolu Server.
+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;
+
+const timestampToKey = (timestamp: Timestamp): string =>
+  Math.floor(timestamp.millis / 1000 / 60).toString(3);
+
+const insertKey = (
+  tree: MerkleTree,
+  key: string,
+  hash: TimestampHash,
+): MerkleTree => {
+  if (key.length === 0) return tree;
+  const childKey = key[0] as "0" | "1" | "2";
+  const child = tree[childKey] || {};
+  return {
+    ...tree,
+    [childKey]: {
+      ...child,
+      ...insertKey(child, key.slice(1), hash),
+      // @ts-expect-error undefined is OK
+      hash: child.hash ^ hash,
+    },
+  };
+};
+
+export const insertIntoMerkleTree =
+  (timestamp: Timestamp) =>
+  (tree: MerkleTree): MerkleTree => {
+    const key = timestampToKey(timestamp);
+    const hash = timestampToHash(timestamp);
+    // @ts-expect-error undefined is OK
+    return insertKey({ ...tree, hash: tree.hash ^ hash }, key, hash);
+  };
+
+const keyToTimestamp = (key: string): Millis =>
+  (parseInt(key.length > 0 ? key : "0", 3) * 1000 * 60) as Millis;
+
+export const diffMerkleTrees = (
+  tree1: MerkleTree,
+  tree2: MerkleTree,
+): Option.Option<Millis> => {
+  if (tree1.hash === tree2.hash) return Option.none();
+  for1: for (let node1 = tree1, node2 = tree2, key = ""; ; ) {
+    for (const k of ["0", "1", "2"] as const) {
+      const next1 = node1[k];
+      const next2 = node2[k];
+      if (!next1 && !next2) continue;
+      if (!next1 || !next2) break;
+      if (next1.hash !== next2.hash) {
+        key += k;
+        node1 = next1;
+        node2 = next2;
+        continue for1;
+      }
+    }
+    return Option.some(keyToTimestamp(key));
+  }
+};
+
+export const merkleTreeToString = (m: MerkleTree): MerkleTreeString =>
+  JSON.stringify(m) as MerkleTreeString;
+
+export const unsafeMerkleTreeFromString = (m: MerkleTreeString): MerkleTree =>
+  JSON.parse(m) as MerkleTree;

package/src/Model.ts

@@ -0,0 +1,212 @@
+import * as Schema from "@effect/schema/Schema";
+import { Brand } from "effect";
+import { Row, maybeJson } from "./Sqlite.js";
+
+/**
+ * Branded Id Schema for any table Id.
+ * To create Id Schema for a specific table, use {@link id}.
+ */
+export const Id = Schema.string.pipe(
+  Schema.pattern(/^[\w-]{21}$/),
+  Schema.brand("Id"),
+);
+export type Id = Schema.Schema.To<typeof Id>;
+
+/**
+ * A factory function to create {@link Id} Schema for a specific table.
+ *
+ * ### Example
+ *
+ * ```
+ * import * as Schema from "@effect/schema/Schema";
+ * import * as Evolu from "@evolu/react";
+ *
+ * const TodoId = Evolu.id("Todo");
+ * type TodoId = Schema.Schema.To<typeof TodoId>;
+ *
+ * if (!Schema.is(TodoId)(value)) return;
+ * ```
+ */
+export const id = <T extends string>(
+  table: T,
+): Schema.BrandSchema<string, string & Brand.Brand<"Id"> & Brand.Brand<T>> =>
+  Id.pipe(Schema.brand(table));
+
+/**
+ * SQLite doesn't support the Date type, so Evolu uses SqliteDate instead.
+ * Use the {@link cast} helper to cast SqliteDate from Date and back.
+ * https://www.sqlite.org/quirks.html#no_separate_datetime_datatype
+ */
+export const SqliteDate = Schema.string.pipe(
+  Schema.filter((s) => !isNaN(Date.parse(s))),
+  Schema.brand("SqliteDate"),
+);
+export type SqliteDate = Schema.Schema.To<typeof SqliteDate>;
+
+/**
+ * SQLite doesn't support the boolean type, so Evolu uses SqliteBoolean instead.
+ * Use the {@link cast} helper to cast SqliteBoolean from boolean and back.
+ * https://www.sqlite.org/quirks.html#no_separate_boolean_datatype
+ */
+export const SqliteBoolean = Schema.number.pipe(
+  Schema.int(),
+  Schema.filter((s) => s === 0 || s === 1),
+  Schema.brand("SqliteBoolean"),
+);
+export type SqliteBoolean = Schema.Schema.To<typeof SqliteBoolean>;
+
+/**
+ * SQLite doesn't support Date nor Boolean types, so Evolu emulates them
+ * with {@link SqliteBoolean} and {@link SqliteDate}.
+ *
+ * For {@link SqliteBoolean}, you can use JavaScript boolean.
+ * For {@link SqliteDate}, you can use JavaScript Date.
+ */
+export type CastableForMutate<T> = {
+  readonly [K in keyof T]: T[K] extends SqliteBoolean
+    ? boolean | SqliteBoolean
+    : T[K] extends null | SqliteBoolean
+    ? null | boolean | SqliteBoolean
+    : T[K] extends SqliteDate
+    ? Date | SqliteDate
+    : T[K] extends null | SqliteDate
+    ? null | Date | SqliteDate
+    : T[K];
+};
+
+/**
+ * A helper for casting types not supported by SQLite.
+ * SQLite doesn't support Date nor Boolean types, so Evolu emulates them
+ * with {@link SqliteBoolean} and {@link SqliteDate}.
+ *
+ * ### Example
+ *
+ * ```
+ * // isDeleted is SqliteBoolean
+ * .where("isDeleted", "is not", cast(true))
+ * ```
+ */
+export function cast(value: boolean): SqliteBoolean;
+export function cast(value: SqliteBoolean): boolean;
+export function cast(value: Date): SqliteDate;
+export function cast(value: SqliteDate): Date;
+export function cast(
+  value: boolean | SqliteBoolean | Date | SqliteDate,
+): boolean | SqliteBoolean | Date | SqliteDate {
+  if (typeof value === "boolean")
+    return (value === true ? 1 : 0) as SqliteBoolean;
+  if (typeof value === "number") return value === 1;
+  if (value instanceof Date) return value.toISOString() as SqliteDate;
+  return new Date(value);
+}
+
+/**
+ * String schema represents a string that is not stringified JSON. Using
+ * String schema for strings stored in SQLite is crucial to ensure a stored
+ * string is not automatically parsed to a JSON object or array when
+ * retrieved. Use String schema for all string-based schemas.
+ */
+export const String = Schema.string.pipe(
+  Schema.filter(
+    (s) => {
+      if (!maybeJson(s)) return true;
+      try {
+        JSON.parse(s);
+      } catch (e) {
+        return true;
+      }
+      return false;
+    },
+    { message: () => "a string that is not stringified JSON" },
+  ),
+  Schema.brand("String"),
+);
+export type String = Schema.Schema.To<typeof String>;
+
+/**
+ * A string with a maximum length of 1000 characters.
+ *
+ * ### Example
+ *
+ * ```
+ * import * as Schema from "@effect/schema/Schema";
+ * import * as Evolu from "@evolu/react";
+ *
+ * if (!Schema.is(Evolu.String1000)(value)) return;
+ * function foo(value: Evolu.String1000) {}
+ * ```
+ */
+export const String1000 = String.pipe(
+  Schema.maxLength(1000),
+  Schema.brand("String1000"),
+);
+export type String1000 = Schema.Schema.To<typeof String1000>;
+
+/**
+ * A nonempty string with a maximum length of 1000 characters.
+ *
+ * ### Example
+ *
+ * ```
+ * import * as Schema from "@effect/schema/Schema";
+ * import * as Evolu from "@evolu/react";
+ *
+ * if (!Schema.is(Evolu.NonEmptyString1000)(value)) return;
+ * function foo(value: Evolu.NonEmptyString1000) {}
+ * ```
+ */
+export const NonEmptyString1000 = String.pipe(
+  Schema.minLength(1),
+  Schema.maxLength(1000),
+  Schema.brand("NonEmptyString1000"),
+);
+export type NonEmptyString1000 = Schema.Schema.To<typeof NonEmptyString1000>;
+
+/**
+ * A positive integer.
+ *
+ * ### Example
+ *
+ * ```
+ * import * as Schema from "@effect/schema/Schema";
+ * import * as Evolu from "@evolu/react";
+ *
+ * if (!Schema.is(Evolu.PositiveInt)(value)) return;
+ * function foo(value: Evolu.PositiveInt) {}
+ * ```
+ */
+export const PositiveInt = Schema.number.pipe(
+  Schema.int(),
+  Schema.positive(),
+  Schema.brand("PositiveInt"),
+);
+export type PositiveInt = Schema.Schema.To<typeof PositiveInt>;
+
+/**
+ * Filter and map array items in one step with the correct return type and
+ * without unreliable TypeScript type guards.
+ *
+ * ### Examples
+ *
+ * ```
+ * useQuery(
+ *   (db) => db.selectFrom("todo").selectAll(),
+ *   // Filter and map nothing.
+ *   (row) => row,
+ * );
+ *
+ * useQuery(
+ *   (db) => db.selectFrom("todo").selectAll(),
+ *   // Filter items with title != null.
+ *   // Note the title type isn't nullable anymore in rows.
+ *   ({ title, ...rest }) => title != null && { title, ...rest },
+ * );
+ * ```
+ */
+export type FilterMap<QueryRow extends Row, FilterMapRow extends Row> = (
+  row: QueryRow,
+) => OrNullOrFalse<FilterMapRow>;
+
+export type OrNullOrFalse<T> = T | null | false;
+
+export type ExcludeNullAndFalse<T> = Exclude<T, null | false>;

package/src/Murmurhash.ts

@@ -0,0 +1,70 @@
+// https://github.com/garycourt/murmurhash-js/blob/master/murmurhash3_gc.js
+export const murmurhash = (key: string, seed = 0): number => {
+  let h1, h1b, k1, i;
+
+  const remainder = key.length & 3; // key.length % 4
+  const bytes = key.length - remainder;
+  h1 = seed;
+  const c1 = 0xcc9e2d51;
+  const c2 = 0x1b873593;
+  i = 0;
+
+  while (i < bytes) {
+    k1 =
+      (key.charCodeAt(i) & 0xff) |
+      ((key.charCodeAt(++i) & 0xff) << 8) |
+      ((key.charCodeAt(++i) & 0xff) << 16) |
+      ((key.charCodeAt(++i) & 0xff) << 24);
+    ++i;
+
+    k1 =
+      ((k1 & 0xffff) * c1 + ((((k1 >>> 16) * c1) & 0xffff) << 16)) & 0xffffffff;
+    k1 = (k1 << 15) | (k1 >>> 17);
+    k1 =
+      ((k1 & 0xffff) * c2 + ((((k1 >>> 16) * c2) & 0xffff) << 16)) & 0xffffffff;
+
+    h1 ^= k1;
+    h1 = (h1 << 13) | (h1 >>> 19);
+    h1b =
+      ((h1 & 0xffff) * 5 + ((((h1 >>> 16) * 5) & 0xffff) << 16)) & 0xffffffff;
+    h1 = (h1b & 0xffff) + 0x6b64 + ((((h1b >>> 16) + 0xe654) & 0xffff) << 16);
+  }
+
+  k1 = 0;
+
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+    // eslint-disable-next-line no-fallthrough
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+    // eslint-disable-next-line no-fallthrough
+    case 1:
+      k1 ^= key.charCodeAt(i) & 0xff;
+
+      k1 =
+        ((k1 & 0xffff) * c1 + ((((k1 >>> 16) * c1) & 0xffff) << 16)) &
+        0xffffffff;
+      k1 = (k1 << 15) | (k1 >>> 17);
+      k1 =
+        ((k1 & 0xffff) * c2 + ((((k1 >>> 16) * c2) & 0xffff) << 16)) &
+        0xffffffff;
+      h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+
+  h1 ^= h1 >>> 16;
+  h1 =
+    ((h1 & 0xffff) * 0x85ebca6b +
+      ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16)) &
+    0xffffffff;
+  h1 ^= h1 >>> 13;
+  h1 =
+    ((h1 & 0xffff) * 0xc2b2ae35 +
+      ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16)) &
+    0xffffffff;
+  h1 ^= h1 >>> 16;
+
+  return h1 >>> 0;
+};

package/src/Platform.ts

@@ -0,0 +1,63 @@
+import { Context, Effect, Layer } from "effect";
+
+export interface Platform {
+  readonly name:
+    | "server"
+    | "web-with-opfs"
+    | "web-without-opfs"
+    | "react-native";
+}
+
+export const Platform = Context.Tag<Platform>("evolu/Platform");
+
+export type FlushSync = (callback: () => void) => void;
+
+export const FlushSync = Context.Tag<FlushSync>("evolu/FlushSync");
+
+export interface SyncLock {
+  readonly acquire: Effect.Effect<never, never, boolean>;
+  readonly release: Effect.Effect<never, never, void>;
+}
+
+export const SyncLock = Context.Tag<SyncLock>("evolu/SyncLock");
+
+export type Fetch = (
+  url: string,
+  body: Uint8Array,
+) => Effect.Effect<never, FetchError, Response>;
+
+export const Fetch = Context.Tag<Fetch>("evolu/Fetch");
+
+/**
+ * This error occurs when there is a problem with the network connection,
+ * or the server cannot be reached.
+ */
+export interface FetchError {
+  readonly _tag: "FetchError";
+}
+
+export const FetchLive = Layer.succeed(
+  Fetch,
+  Fetch.of((url, body) =>
+    Effect.tryPromise({
+      try: () =>
+        fetch(url, {
+          method: "POST",
+          body,
+          headers: {
+            "Content-Type": "application/octet-stream",
+            "Content-Length": body.length.toString(),
+          },
+        }),
+      catch: (): FetchError => ({ _tag: "FetchError" }),
+    }),
+  ),
+);
+
+export interface AppState {
+  readonly onFocus: (callback: () => void) => void;
+  readonly onReconnect: (callback: () => void) => void;
+  readonly reset: Effect.Effect<never, never, void>;
+}
+
+export const AppState = Context.Tag<AppState>("evolu/AppState");

package/src/Protobuf.ts

@@ -0,0 +1,204 @@
+/* eslint-disable */
+// @generated by protobuf-ts 2.9.1 with parameter eslint_disable,optimize_code_size
+// @generated from protobuf file "Protobuf.proto" (syntax proto3)
+// tslint:disable
+import { MessageType } from "@protobuf-ts/runtime";
+import { MerkleTreeString } from "./MerkleTree.js";
+import { OwnerId } from "./Db.js";
+import { NodeId } from "./Crypto.js";
+import { TimestampString } from "./Timestamp.js";
+import { Id } from "./Model.js";
+/**
+ * @generated from protobuf message SyncRequest
+ */
+export interface SyncRequest {
+  /**
+   * @generated from protobuf field: repeated EncryptedMessage messages = 1;
+   */
+  messages: ReadonlyArray<EncryptedMessage>;
+  /**
+   * @generated from protobuf field: string userId = 2;
+   */
+  userId: OwnerId;
+  /**
+   * @generated from protobuf field: string nodeId = 3;
+   */
+  nodeId: NodeId;
+  /**
+   * @generated from protobuf field: string merkleTree = 4;
+   */
+  merkleTree: MerkleTreeString;
+}
+/**
+ * @generated from protobuf message SyncResponse
+ */
+export interface SyncResponse {
+  /**
+   * @generated from protobuf field: repeated EncryptedMessage messages = 1;
+   */
+  messages: ReadonlyArray<EncryptedMessage>;
+  /**
+   * @generated from protobuf field: string merkleTree = 2;
+   */
+  merkleTree: MerkleTreeString;
+}
+/**
+ * @generated from protobuf message EncryptedMessage
+ */
+export interface EncryptedMessage {
+  /**
+   * @generated from protobuf field: string timestamp = 1;
+   */
+  timestamp: TimestampString;
+  /**
+   * @generated from protobuf field: bytes content = 2;
+   */
+  content: Uint8Array;
+}
+/**
+ * @generated from protobuf message MessageContent
+ */
+export interface MessageContent {
+  /**
+   * @generated from protobuf field: string table = 1;
+   */
+  table: string;
+  /**
+   * @generated from protobuf field: string row = 2;
+   */
+  row: Id;
+  /**
+   * @generated from protobuf field: string column = 3;
+   */
+  column: string;
+  /**
+   * @generated from protobuf oneof: value
+   */
+  value:
+    | {
+        oneofKind: "stringValue";
+        /**
+         * @generated from protobuf field: string stringValue = 4;
+         */
+        stringValue: string;
+      }
+    | {
+        oneofKind: "numberValue";
+        /**
+         * @generated from protobuf field: int32 numberValue = 5;
+         */
+        numberValue: number;
+      }
+    | {
+        oneofKind: "bytesValue";
+        /**
+         * @generated from protobuf field: bytes bytesValue = 6;
+         */
+        bytesValue: Uint8Array;
+      }
+    | {
+        oneofKind: "jsonValue";
+        /**
+         * @generated from protobuf field: string jsonValue = 7;
+         */
+        jsonValue: string;
+      }
+    | {
+        oneofKind: undefined;
+      };
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class SyncRequest$Type extends MessageType<SyncRequest> {
+  constructor() {
+    super("SyncRequest", [
+      {
+        no: 1,
+        name: "messages",
+        kind: "message",
+        repeat: 1 /*RepeatType.PACKED*/,
+        T: () => EncryptedMessage,
+      },
+      { no: 2, name: "userId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+      { no: 3, name: "nodeId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+      { no: 4, name: "merkleTree", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+    ]);
+  }
+}
+/**
+ * @generated MessageType for protobuf message SyncRequest
+ */
+export const SyncRequest = new SyncRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SyncResponse$Type extends MessageType<SyncResponse> {
+  constructor() {
+    super("SyncResponse", [
+      {
+        no: 1,
+        name: "messages",
+        kind: "message",
+        repeat: 1 /*RepeatType.PACKED*/,
+        T: () => EncryptedMessage,
+      },
+      { no: 2, name: "merkleTree", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+    ]);
+  }
+}
+/**
+ * @generated MessageType for protobuf message SyncResponse
+ */
+export const SyncResponse = new SyncResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EncryptedMessage$Type extends MessageType<EncryptedMessage> {
+  constructor() {
+    super("EncryptedMessage", [
+      { no: 1, name: "timestamp", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+      { no: 2, name: "content", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+    ]);
+  }
+}
+/**
+ * @generated MessageType for protobuf message EncryptedMessage
+ */
+export const EncryptedMessage = new EncryptedMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MessageContent$Type extends MessageType<MessageContent> {
+  constructor() {
+    super("MessageContent", [
+      { no: 1, name: "table", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+      { no: 2, name: "row", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+      { no: 3, name: "column", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+      {
+        no: 4,
+        name: "stringValue",
+        kind: "scalar",
+        oneof: "value",
+        T: 9 /*ScalarType.STRING*/,
+      },
+      {
+        no: 5,
+        name: "numberValue",
+        kind: "scalar",
+        oneof: "value",
+        T: 5 /*ScalarType.INT32*/,
+      },
+      {
+        no: 6,
+        name: "bytesValue",
+        kind: "scalar",
+        oneof: "value",
+        T: 12 /*ScalarType.BYTES*/,
+      },
+      {
+        no: 7,
+        name: "jsonValue",
+        kind: "scalar",
+        oneof: "value",
+        T: 9 /*ScalarType.STRING*/,
+      },
+    ]);
+  }
+}
+/**
+ * @generated MessageType for protobuf message MessageContent
+ */
+export const MessageContent = new MessageContent$Type();

package/src/Public.ts

@@ -0,0 +1,6 @@
+export { jsonArrayFrom, jsonObjectFrom } from "kysely/helpers/sqlite";
+export type { Mnemonic } from "./Crypto.js";
+export type { Owner, OwnerId } from "./Db.js";
+export type { EvoluError } from "./Errors.js";
+export * from "./Model.js";
+export type { SyncState } from "./SyncWorker.js";