@evolu/common 3.1.8 → 4.0.1

package/src/DbWorker.ts

@@ -1,4 +1,3 @@
-import { hexToBytes } from "@noble/ciphers/utils";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
@@ -11,6 +10,7 @@ import * as ReadonlyRecord from "effect/ReadonlyRecord";
 import { Config, ConfigLive } from "./Config.js";
 import {
   MerkleTree,
+  Millis,
   Time,
   TimeLive,
   Timestamp,
@@ -28,7 +28,7 @@ import {
   timestampToString,
   unsafeTimestampFromString,
 } from "./Crdt.js";
-import { Bip39, Mnemonic, NanoId } from "./Crypto.js";
+import { Bip39, Mnemonic, NanoIdGenerator } from "./Crypto.js";
 import {
   Queries,
   Query,
@@ -44,9 +44,10 @@ import {
 } from "./Db.js";
 import { QueryPatches, makePatches } from "./Diff.js";
 import { EvoluError, makeUnexpectedError } from "./ErrorStore.js";
-import { Id, SqliteDate, cast } from "./Model.js";
+import { Id, cast } from "./Model.js";
 import { OnCompleteId } from "./OnCompletes.js";
 import { Owner, OwnerId } from "./Owner.js";
+import { DbWorkerLock } from "./Platform.js";
 import * as Sql from "./Sql.js";
 import { Sqlite, Value } from "./Sqlite.js";
 import {
@@ -58,12 +59,9 @@ import {
   SyncWorkerOutputSyncResponse,
   SyncWorkerPostMessage,
 } from "./SyncWorker.js";
+import { Messaging } from "./Types.js";
 
-export interface DbWorker {
-  readonly postMessage: (input: DbWorkerInput) => void;
-  onMessage: (output: DbWorkerOutput) => void;
-}
-
+export interface DbWorker extends Messaging<DbWorkerInput, DbWorkerOutput> {}
 export const DbWorker = Context.GenericTag<DbWorker>("@services/DbWorker");
 
 export type DbWorkerInput =
@@ -157,7 +155,6 @@ export interface Mutation {
     Value | Date | boolean | undefined
   >;
   readonly isInsert: boolean;
-  readonly now: SqliteDate;
   readonly onCompleteId: OnCompleteId | null;
 }
 
@@ -170,8 +167,7 @@ const init = Effect.gen(function* (_) {
       ({ rows: [row] }): Owner => ({
         id: row.id as OwnerId,
         mnemonic: row.mnemonic as Mnemonic,
-        // expo-sqlite 11.3.2 doesn't support Uint8Array
-        encryptionKey: hexToBytes(row.encryptionKey as string),
+        encryptionKey: row.encryptionKey as Uint8Array,
       }),
     ),
     someDefectToNoSuchTableOrColumnError,
@@ -222,9 +218,8 @@ const readTimestampAndMerkleTree = Sqlite.pipe(
   Effect.flatMap((sqlite) =>
     sqlite.exec(Sql.selectOwnerTimestampAndMerkleTree),
   ),
-  Effect.map((result) => result.rows),
   Effect.map(
-    ([{ timestamp, merkleTree }]): TimestampAndMerkleTree => ({
+    ({ rows: [{ timestamp, merkleTree }] }): TimestampAndMerkleTree => ({
       timestamp: unsafeTimestampFromString(timestamp as TimestampString),
       merkleTree: merkleTree as MerkleTree,
     }),
@@ -236,9 +231,10 @@ export const mutationsToNewMessages = (
 ): ReadonlyArray<NewMessage> =>
   pipe(
     mutations,
-    ReadonlyArray.map(({ id, isInsert, now, table, values }) =>
+    ReadonlyArray.map(({ id, isInsert, table, values }) =>
       pipe(
         Object.entries(values),
+        // Filter values.
         ReadonlyArray.filterMap(([key, value]) =>
           // The value can be undefined if exactOptionalPropertyTypes isn't true.
           // Don't insert nulls because null is the default value.
@@ -246,6 +242,7 @@ export const mutationsToNewMessages = (
             ? Option.none()
             : Option.some([key, value] as const),
         ),
+        // Cast values.
         ReadonlyArray.map(
           ([key, value]) =>
             [
@@ -257,7 +254,6 @@ export const mutationsToNewMessages = (
                   : value,
             ] as const,
         ),
-        ReadonlyArray.append([isInsert ? "createdAt" : "updatedAt", now]),
         ReadonlyArray.map(
           ([key, value]): NewMessage => ({
             table,
@@ -282,7 +278,7 @@ const ensureSchemaByNewMessages = (
       if (table == null) {
         tablesMap.set(message.table, {
           name: message.table,
-          columns: [message.column],
+          columns: [message.column, "createdAt", "updatedAt"],
         });
         return;
       }
@@ -298,13 +294,21 @@ const ensureSchemaByNewMessages = (
 export const upsertValueIntoTableRowColumn = (
   message: NewMessage,
   messages: ReadonlyArray<NewMessage>,
+  millis: Millis,
 ): Effect.Effect<void, never, Sqlite> =>
   Effect.gen(function* (_) {
     const sqlite = yield* _(Sqlite);
-
+    const createdAtOrUpdatedAt = cast(new Date(millis));
     const insert = sqlite.exec({
       sql: Sql.upsertValueIntoTableRowColumn(message.table, message.column),
-      parameters: [message.row, message.value, message.value],
+      parameters: [
+        message.row,
+        message.value,
+        createdAtOrUpdatedAt,
+        createdAtOrUpdatedAt,
+        message.value,
+        createdAtOrUpdatedAt,
+      ],
     });
 
     yield* _(
@@ -340,7 +344,8 @@ const applyMessages = ({
       );
 
       if (timestamp == null || timestamp < message.timestamp) {
-        yield* _(upsertValueIntoTableRowColumn(message, messages));
+        const { millis } = unsafeTimestampFromString(message.timestamp);
+        yield* _(upsertValueIntoTableRowColumn(message, messages, millis));
       }
 
       if (timestamp == null || timestamp !== message.timestamp) {
@@ -406,11 +411,11 @@ const mutate = ({
       ),
     ).map(mutationsToNewMessages);
 
-    yield* _(
-      Effect.forEach(toUpsert, (message) =>
-        upsertValueIntoTableRowColumn(message, toUpsert),
-      ),
-    );
+    const time = yield* _(Time);
+    for (const messageToUpsert of toUpsert) {
+      const now = yield* _(time.now);
+      yield* _(upsertValueIntoTableRowColumn(messageToUpsert, toUpsert, now));
+    }
 
     const { exec } = yield* _(Sqlite);
     yield* _(
@@ -537,8 +542,8 @@ const sync = ({
 > =>
   Effect.gen(function* (_) {
     if (queries.length > 0) yield* _(query({ queries }));
-
-    (yield* _(SyncWorkerPostMessage))({
+    const syncWorkerPostMessage = yield* _(SyncWorkerPostMessage);
+    syncWorkerPostMessage({
       _tag: "sync",
       ...(yield* _(readTimestampAndMerkleTree)),
       syncUrl: (yield* _(Config)).syncUrl,
@@ -550,7 +555,11 @@ const sync = ({
 
 const reset = (
   input: DbWorkerInputReset,
-): Effect.Effect<void, never, Sqlite | Bip39 | NanoId | DbWorkerOnMessage> =>
+): Effect.Effect<
+  void,
+  never,
+  Sqlite | Bip39 | NanoIdGenerator | DbWorkerOnMessage
+> =>
   Effect.gen(function* (_) {
     const sqlite = yield* _(Sqlite);
 
@@ -575,7 +584,7 @@ const reset = (
     onMessage({ _tag: "onResetOrRestore" });
   });
 
-export const DbWorkerLive = Layer.effect(
+export const DbWorkerCommonLive = Layer.effect(
   DbWorker,
   Effect.gen(function* (_) {
     const syncWorker = yield* _(SyncWorker);
@@ -591,7 +600,7 @@ export const DbWorkerLive = Layer.effect(
           onError(output).pipe(Effect.runSync);
           break;
         case "SyncWorkerOutputSyncResponse":
-          postMessage(output);
+          dbWorker.postMessage(output);
           break;
         default:
           dbWorker.onMessage({ _tag: "onSyncState", state: output });
@@ -601,7 +610,7 @@ export const DbWorkerLive = Layer.effect(
     const runContext = Context.empty().pipe(
       Context.add(Sqlite, yield* _(Sqlite)),
       Context.add(Bip39, yield* _(Bip39)),
-      Context.add(NanoId, yield* _(NanoId)),
+      Context.add(NanoIdGenerator, yield* _(NanoIdGenerator)),
       Context.add(DbWorkerOnMessage, (output) => {
         dbWorker.onMessage(output);
       }),
@@ -611,7 +620,7 @@ export const DbWorkerLive = Layer.effect(
       effect: Effect.Effect<
         void,
         EvoluError,
-        Sqlite | Bip39 | NanoId | DbWorkerOnMessage
+        Sqlite | Bip39 | NanoIdGenerator | DbWorkerOnMessage
       >,
     ): Promise<void> =>
       effect.pipe(
@@ -622,15 +631,18 @@ export const DbWorkerLive = Layer.effect(
         Effect.runPromise,
       );
 
-    type Write = (input: DbWorkerInput) => Promise<void>;
+    type HandleInput = (input: DbWorkerInput) => Promise<void>;
 
-    // Write for reset only in case init fails.
-    const writeForInitFail: Write = (input): Promise<void> => {
+    /** If init fails, we have to allow reset at least. */
+    const handleInputForInitFail: HandleInput = (input): Promise<void> => {
       if (input._tag !== "reset") return Promise.resolve(undefined);
       return reset(input).pipe(run);
     };
 
-    const makeWriteForInitSuccess = (config: Config, owner: Owner): Write => {
+    const makeHandleInputForInitSuccess = (
+      config: Config,
+      owner: Owner,
+    ): HandleInput => {
       let skipAllBecauseOfReset = false;
 
       const layer = Layer.mergeAll(
@@ -663,27 +675,25 @@ export const DbWorkerLive = Layer.effect(
       };
     };
 
-    let write: Write = (input) => {
+    let handleInput: HandleInput = (input) => {
       if (input._tag !== "init")
         return run(makeUnexpectedError(new Error("init must be called first")));
-      write = writeForInitFail;
+      handleInput = handleInputForInitFail;
       return init.pipe(
         Effect.map((owner) => {
           dbWorker.onMessage({ _tag: "onOwner", owner });
-          write = makeWriteForInitSuccess(input.config, owner);
+          handleInput = makeHandleInputForInitSuccess(input.config, owner);
         }),
         run,
       );
     };
 
-    let messageQueue: Promise<void> = Promise.resolve(undefined);
-
-    const postMessage: DbWorker["postMessage"] = (input) => {
-      messageQueue = messageQueue.then(() => write(input));
-    };
+    const dbWorkerLock = yield* _(DbWorkerLock);
 
     const dbWorker: DbWorker = {
-      postMessage,
+      postMessage: (input) => {
+        dbWorkerLock(() => handleInput(input));
+      },
       onMessage: Function.constVoid,
     };
 

package/src/Evolu.ts

@@ -10,8 +10,7 @@ import * as Number from "effect/Number";
 import * as ReadonlyArray from "effect/ReadonlyArray";
 import * as Kysely from "kysely";
 import { Config, ConfigLive } from "./Config.js";
-import { Time, TimeLive } from "./Crdt.js";
-import { Mnemonic, NanoId, NanoIdLive } from "./Crypto.js";
+import { Mnemonic, NanoIdGenerator, NanoIdGeneratorLive } from "./Crypto.js";
 import {
   DatabaseSchema,
   Queries,
@@ -29,11 +28,11 @@ import {
 import { DbWorker, DbWorkerOutputOnQuery, Mutation } from "./DbWorker.js";
 import { applyPatches } from "./Diff.js";
 import { EvoluError, makeErrorStore } from "./ErrorStore.js";
-import { SqliteBoolean, SqliteDate, cast } from "./Model.js";
+import { SqliteBoolean, SqliteDate } from "./Model.js";
 import { OnCompletes, OnCompletesLive } from "./OnCompletes.js";
 import { Owner } from "./Owner.js";
 import { AppState, FlushSync, PlatformName } from "./Platform.js";
-import { SqliteQuery } from "./Sqlite.js";
+import { SqliteQuery, isSqlMutation } from "./Sqlite.js";
 import { Store, Unsubscribe, makeStore } from "./Store.js";
 import { SyncState } from "./SyncWorker.js";
 
@@ -319,17 +318,22 @@ type CreateQuery<S extends DatabaseSchema> = <R extends Row>(
 ) => Query<R>;
 
 type QueryCallback<S extends DatabaseSchema, R extends Row> = (
-  db: Pick<Kysely.Kysely<QuerySchema<S>>, "selectFrom" | "fn">,
+  db: Pick<
+    Kysely.Kysely<QuerySchema<S>>,
+    "selectFrom" | "fn" | "with" | "withRecursive"
+  >,
 ) => Kysely.SelectQueryBuilder<any, any, R>;
 
 type QuerySchema<S extends DatabaseSchema> = {
-  readonly [Table in keyof S]: NullableExceptId<{
+  readonly [Table in keyof S]: NullableExceptForIdAndAutomaticColumns<{
     readonly [Column in keyof S[Table]]: S[Table][Column];
   }>;
 };
 
-type NullableExceptId<T> = {
-  readonly [K in keyof T]: K extends "id" ? T[K] : T[K] | null;
+type NullableExceptForIdAndAutomaticColumns<T> = {
+  readonly [K in keyof T]: K extends "id" | "createdAt" | "updatedAt"
+    ? T[K]
+    : T[K] | null;
 };
 
 const kysely = new Kysely.Kysely<QuerySchema<DatabaseSchema>>({
@@ -349,10 +353,14 @@ export const makeCreateQuery =
   <R extends Row>(queryCallback: QueryCallback<S, R>) =>
     pipe(
       queryCallback(kysely as Kysely.Kysely<QuerySchema<S>>).compile(),
-      ({ sql, parameters }): SqliteQuery => ({
-        sql,
-        parameters: parameters as SqliteQuery["parameters"],
-      }),
+      ({ sql, parameters }): SqliteQuery => {
+        if (isSqlMutation(sql))
+          throw new Error(
+            "SQL mutation (INSERT, UPDATE, DELETE, etc.) isn't allowed in the Evolu `createQuery` function. Kysely suggests it because there is no read-only Kysely yet, and removing such an API is not possible. For mutations, use Evolu mutation API.",
+          );
+
+        return { sql, parameters: parameters as SqliteQuery["parameters"] };
+      },
       (query) => serializeQuery<R>(query),
     );
 
@@ -643,9 +651,8 @@ type Castable<T> = {
 const MutateLive = Layer.effect(
   Mutate,
   Effect.gen(function* (_) {
-    const nanoid = yield* _(NanoId);
+    const { nanoid } = yield* _(NanoIdGenerator);
     const onCompletes = yield* _(OnCompletes);
-    const time = yield* _(Time);
     const subscribedQueries = yield* _(SubscribedQueries);
     const loadingPromises = yield* _(LoadingPromises);
     const dbWorker = yield* _(DbWorker);
@@ -653,7 +660,7 @@ const MutateLive = Layer.effect(
 
     return Mutate.of((table, { id, ...values }, onComplete) => {
       const isInsert = id == null;
-      if (isInsert) id = Effect.runSync(nanoid.nanoid) as never;
+      if (isInsert) id = Effect.runSync(nanoid) as never;
 
       const onCompleteId = onComplete
         ? onCompletes.add(onComplete).pipe(Effect.runSync)
@@ -666,7 +673,6 @@ const MutateLive = Layer.effect(
           id,
           values,
           isInsert,
-          now: cast(new Date(Effect.runSync(time.now))),
           onCompleteId,
         },
       ];
@@ -785,9 +791,8 @@ const EvoluCommon = Layer.effect(
   Layer.provide(Layer.merge(RowsStoreLive, OnCompletesLive)),
 );
 
-/** EvoluCommonLive has only platform independent side-effects. */
 export const EvoluCommonLive = EvoluCommon.pipe(
-  Layer.provide(Layer.merge(TimeLive, NanoIdLive)),
+  Layer.provide(NanoIdGeneratorLive),
 );
 
 /**

package/src/OnCompletes.ts

@@ -4,7 +4,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as ReadonlyArray from "effect/ReadonlyArray";
-import { NanoId } from "./Crypto.js";
+import { NanoId, NanoIdGenerator } from "./Crypto.js";
 
 export interface OnCompletes {
   readonly add: (onComplete: OnComplete) => Effect.Effect<OnCompleteId>;
@@ -16,7 +16,7 @@ export interface OnCompletes {
 
 export type OnComplete = () => void;
 
-export type OnCompleteId = string & Brand.Brand<"OnCompleteId">;
+export type OnCompleteId = NanoId & Brand.Brand<"OnCompleteId">;
 
 export const OnCompletes = Context.GenericTag<OnCompletes>(
   "@services/OnCompletes",
@@ -25,12 +25,12 @@ export const OnCompletes = Context.GenericTag<OnCompletes>(
 export const OnCompletesLive = Layer.effect(
   OnCompletes,
   Effect.gen(function* (_) {
-    const nanoid = yield* _(NanoId);
+    const { nanoid } = yield* _(NanoIdGenerator);
     const map = new Map<OnCompleteId, OnComplete>();
 
     return OnCompletes.of({
       add: (onComplete) =>
-        nanoid.nanoid.pipe(
+        nanoid.pipe(
           Effect.map((nanoid) => {
             const id = nanoid as OnCompleteId;
             map.set(id, onComplete);

package/src/Platform.ts

@@ -2,11 +2,7 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 
-export type PlatformName =
-  | "server"
-  | "web-with-opfs"
-  | "web-without-opfs"
-  | "react-native";
+export type PlatformName = "server" | "web" | "react-native";
 
 export const PlatformName = Context.GenericTag<PlatformName>(
   "@services/PlatformName",
@@ -40,6 +36,11 @@ export interface SyncLock {
 
 export const SyncLock = Context.GenericTag<SyncLock>("@services/SyncLock");
 
+export type DbWorkerLock = (callback: () => Promise<void>) => void;
+export const DbWorkerLock = Context.GenericTag<DbWorkerLock>(
+  "@services/DbWorkerLock",
+);
+
 export type Fetch = (
   url: string,
   body: Uint8Array,

package/src/Sql.ts

@@ -3,33 +3,33 @@
 // [Playground Link](https://kyse.link/?p=b&i=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)
 
 export const selectOwner = `
-SELECT
+select
   "id",
   "mnemonic",
   "encryptionKey"
-FROM
+from
   "evolu_owner"
-`;
+`.trim();
 
 export const createMessageTable = `
-CREATE TABLE
+create table
   "evolu_message" (
-    "timestamp" blob PRIMARY KEY,
+    "timestamp" blob primary key,
     "table" blob,
     "row" blob,
     "column" blob,
     "value" blob
   );
-`;
+`.trim();
 
 export const createMessageTableIndex = `
-CREATE INDEX "index_evolu_message" ON "evolu_message" (
+create index "index_evolu_message" on "evolu_message" (
   "table", "row", "column", "timestamp"
 );
-`;
+`.trim();
 
 export const createOwnerTable = `
-CREATE TABLE
+create table
   "evolu_owner" (
     "id" blob,
     "mnemonic" blob,
@@ -37,10 +37,10 @@ CREATE TABLE
     "timestamp" blob,
     "merkleTree" blob
   );
-`;
+`.trim();
 
 export const insertOwner = `
-INSERT INTO
+insert into
   "evolu_owner" (
     "id",
     "mnemonic",
@@ -48,73 +48,76 @@ INSERT INTO
     "timestamp",
     "merkleTree"
   )
-VALUES
+values
   (?, ?, ?, ?, ?);
-`;
+`.trim();
 
 export const selectOwnerTimestampAndMerkleTree = `
-SELECT
+select
   "timestamp",
   "merkleTree"
-FROM
+from
   "evolu_owner"
-`;
+`.trim();
 
 export const selectLastTimestampForTableRowColumn = `
-SELECT
+select
   "timestamp"
-FROM
+from
   "evolu_message"
-WHERE
+where
   "table" = ?
-  AND "row" = ?
-  AND "column" = ?
-ORDER BY
-  "timestamp" DESC
-LIMIT
+  and "row" = ?
+  and "column" = ?
+order by
+  "timestamp" desc
+limit
   1
-`;
+`.trim();
 
 export const upsertValueIntoTableRowColumn = (
   table: string,
   column: string,
-): string => `
-INSERT INTO
-  "${table}" ("id", "${column}")
-VALUES
-  (?, ?)
-ON CONFLICT DO UPDATE SET
-  "${column}" = ?
-`;
+): string =>
+  `
+insert into
+  "${table}" ("id", "${column}", "createdAt", "updatedAt")
+values
+  (?, ?, ?, ?)
+on conflict do update set
+  "${column}" = ?,
+  "updatedAt" = ?
+`.trim();
 
-export const deleteTableRow = (table: string): string => `
-DELETE FROM "${table}"
-WHERE
+export const deleteTableRow = (table: string): string =>
+  `
+delete from "${table}"
+where
   "id" = ?;
-`;
+`.trim();
 
 export const insertIntoMessagesIfNew = `
-INSERT INTO
+insert into
   "evolu_message" ("timestamp", "table", "row", "column", "value")
-VALUES
+values
   (?, ?, ?, ?, ?)
-ON CONFLICT DO NOTHING
-`;
+on conflict do nothing
+`.trim();
 
 export const updateOwnerTimestampAndMerkleTree = `
-UPDATE "evolu_owner"
-SET
+update "evolu_owner"
+set
   "timestamp" = ?,
   "merkleTree" = ?
-`;
+`.trim();
 
 export const selectMessagesToSync = `
-SELECT
+select
   *
-FROM
+from
   "evolu_message"
-WHERE
+where
   "timestamp" >= ?
-ORDER BY
+order by
   "timestamp"
-`;
+`.trim();

package/src/Sqlite.ts

@@ -3,7 +3,7 @@ import * as Effect from "effect/Effect";
 import * as Predicate from "effect/Predicate";
 
 export interface Sqlite {
-  readonly exec: (arg: string | SqliteQuery) => Effect.Effect<ExecResult>;
+  readonly exec: (arg: string | SqliteQuery) => Effect.Effect<SqliteExecResult>;
 }
 
 export const Sqlite = Context.GenericTag<Sqlite>("@services/Sqlite");
@@ -21,7 +21,7 @@ type JsonArray = ReadonlyArray<Json>;
 type JsonPrimitive = string | number | boolean | null;
 type Json = JsonPrimitive | JsonObject | JsonArray;
 
-interface ExecResult {
+export interface SqliteExecResult {
   readonly rows: SqliteRow[];
   readonly changes: number;
 }
@@ -80,3 +80,19 @@ const parseObject = (o: Record<string, unknown>): Record<string, unknown> => {
   for (const key in o) o[key] = parse(o[key]);
   return o;
 };
+
+/** This is good enough detection because SQL strings in Evolu are predictable. */
+const isSqlMutationRegEx = new RegExp(
+  `\\b(${[
+    "alter",
+    "create",
+    "delete",
+    "drop",
+    "insert",
+    "replace",
+    "update",
+  ].join("|")})\\b`,
+);
+
+export const isSqlMutation = (sql: string): boolean =>
+  isSqlMutationRegEx.test(sql);

package/src/SyncWorker.ts

@@ -31,12 +31,10 @@ import {
   SyncResponse,
 } from "./Protobuf.js";
 import { JsonObjectOrArray, Value } from "./Sqlite.js";
+import { Messaging } from "./Types.js";
 
-export interface SyncWorker {
-  readonly postMessage: (input: SyncWorkerInput) => void;
-  onMessage: (output: SyncWorkerOutput) => void;
-}
-
+export interface SyncWorker
+  extends Messaging<SyncWorkerInput, SyncWorkerOutput> {}
 export const SyncWorker = Context.GenericTag<SyncWorker>(
   "@services/SyncWorker",
 );
@@ -325,7 +323,7 @@ const sync = (
     );
   });
 
-export const SyncWorkerLive = Layer.effect(
+export const SyncWorkerCommonLive = Layer.effect(
   SyncWorker,
   Effect.gen(function* (_) {
     const syncLock = yield* _(SyncLock);