@evolu/common 4.1.0 → 5.0.0

package/src/Model.ts

@@ -1,8 +1,9 @@
 import * as S from "@effect/schema/Schema";
-import { maybeJson } from "./Sqlite.js";
+import * as Types from "effect/Types";
+import { Value, maybeJson } from "./Sqlite.js";
 
 /** Branded Id Schema. To create Id Schema for a specific table, use {@link id}. */
-export const Id = S.string.pipe(S.pattern(/^[\w-]{21}$/), S.brand("Id"));
+export const Id = S.String.pipe(S.pattern(/^[\w-]{21}$/), S.brand("Id"));
 export type Id = S.Schema.Type<typeof Id>;
 
 /**
@@ -25,7 +26,7 @@ export const id = <T extends string>(
  * the {@link cast} helper to cast SqliteDate from Date and back.
  * https://www.sqlite.org/quirks.html#no_separate_datetime_datatype
  */
-export const SqliteDate = S.string.pipe(
+export const SqliteDate = S.String.pipe(
   S.filter((s) => !isNaN(Date.parse(s))),
   S.brand("SqliteDate"),
 );
@@ -36,7 +37,7 @@ export type SqliteDate = S.Schema.Type<typeof SqliteDate>;
  * 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 = S.number.pipe(
+export const SqliteBoolean = S.Number.pipe(
   S.int(),
   S.filter((s) => s === 0 || s === 1),
   S.brand("SqliteBoolean"),
@@ -71,13 +72,108 @@ export function cast(
   return new Date(value);
 }
 
+interface EvoluTypeError<E extends string> {
+  readonly __evoluTypeError__: E;
+}
+
+/**
+ * Create table schema.
+ *
+ * Supported types are null, string, number, Uint8Array, JSON Object, and JSON
+ * Array. Use SqliteDate for dates and SqliteBoolean for booleans.
+ *
+ * Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added
+ * by default.
+ *
+ * @example
+ *   const TodoId = id("Todo");
+ *   type TodoId = S.Schema.Type<typeof TodoId>;
+ *
+ *   const TodoTable = table({
+ *     id: TodoId,
+ *     title: NonEmptyString1000,
+ *     isCompleted: S.nullable(SqliteBoolean),
+ *   });
+ *   type TodoTable = S.Schema.Type<typeof TodoTable>;
+ */
+export const table = <Fields extends TableFields>(
+  fields: Fields,
+  // Because Schema is invariant, we have to do validation like this.
+): ValidateFieldsTypes<Fields> extends true
+  ? ValidateFieldsNames<Fields> extends true
+    ? ValidateFieldsHasId<Fields> extends true
+      ? S.Schema<
+          Types.Simplify<
+            S.Struct.Type<Fields> & S.Schema.Type<typeof ReservedColumns>
+          >,
+          Types.Simplify<
+            S.Struct.Encoded<Fields> & S.Schema.Encoded<typeof ReservedColumns>
+          >
+        >
+      : EvoluTypeError<"table() called without id column.">
+    : EvoluTypeError<"table() called with a reserved column. Reserved columns are createdAt, updatedAt, isDeleted. Those columns are added by default.">
+  : EvoluTypeError<"table() called with unsupported type. Supported types are null, string, number, Uint8Array, JSON Object, and JSON Array. Use SqliteDate for dates and SqliteBoolean for booleans."> =>
+  S.Struct(fields).pipe(S.extend(ReservedColumns)) as never;
+
+const ReservedColumns = S.Struct({
+  createdAt: SqliteDate,
+  updatedAt: SqliteDate,
+  isDeleted: SqliteBoolean,
+});
+
+type TableFields = Record<string, S.Schema<any>>;
+
+type ValidateFieldsTypes<Fields extends TableFields> =
+  keyof Fields extends infer K
+    ? K extends keyof Fields
+      ? Fields[K] extends TableFields
+        ? ValidateFieldsTypes<Fields[K]>
+        : // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          Fields[K] extends S.Schema<infer A, infer _I>
+          ? A extends Value
+            ? true
+            : false
+          : never
+      : never
+    : never;
+
+type ValidateFieldsNames<Fields extends TableFields> =
+  keyof Fields extends infer K
+    ? K extends keyof Fields
+      ? K extends "createdAt" | "updatedAt" | "isDeleted"
+        ? false
+        : true
+      : never
+    : never;
+
+type ValidateFieldsHasId<Fields extends TableFields> = "id" extends keyof Fields
+  ? true
+  : false;
+
+/**
+ * Create database schema.
+ *
+ * Tables with a name prefixed with _ are local-only, which means they are not
+ * synced. Local-only tables are useful for device-specific or temporal data.
+ *
+ * @example
+ *   const Database = database({
+ *     // A local-only table.
+ *     _todo: TodoTable,
+ *     todo: TodoTable,
+ *     todoCategory: TodoCategoryTable,
+ *   });
+ *   type Database = S.Schema.Type<typeof Database>;
+ */
+export const database = S.Struct;
+
 /**
  * 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 = S.string.pipe(
+export const String = S.String.pipe(
   S.filter(
     (s) => {
       if (!maybeJson(s)) return true;
@@ -131,7 +227,7 @@ export type NonEmptyString1000 = S.Schema.Type<typeof NonEmptyString1000>;
  *
  *   S.decode(PositiveInt)(value);
  */
-export const PositiveInt = S.number.pipe(
+export const PositiveInt = S.Number.pipe(
   S.int(),
   S.positive(),
   S.brand("PositiveInt"),

package/src/Owner.ts

@@ -1,7 +1,6 @@
 import * as Brand from "effect/Brand";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import { urlAlphabet } from "nanoid";
 import { Bip39, Mnemonic, slip21Derive } from "./Crypto.js";
 import { Id } from "./Model.js";
 
@@ -28,7 +27,7 @@ export interface Owner {
   readonly encryptionKey: Uint8Array;
 }
 
-export const Owner = Context.GenericTag<Owner>("@services/Owner");
+export const Owner = Context.GenericTag<Owner>("Owner");
 
 /**
  * The unique identifier of {@link Owner} safely derived from its
@@ -40,28 +39,29 @@ export const makeOwner = (
   mnemonic?: Mnemonic,
 ): Effect.Effect<Owner, never, Bip39> =>
   Effect.gen(function* (_) {
-    const bip39 = yield* _(Bip39);
-
-    if (mnemonic == null) mnemonic = yield* _(bip39.make);
-
-    const seed = yield* _(bip39.toSeed(mnemonic));
-
-    const id = yield* _(
-      slip21Derive(seed, ["Evolu", "Owner Id"]).pipe(
-        Effect.map((key) => {
-          // convert key to nanoid
-          let id = "";
-          for (let i = 0; i < 21; i++) {
-            id += urlAlphabet[key[i] & 63];
-          }
-          return id as OwnerId;
-        }),
-      ),
+    const bip39 = yield* Bip39;
+    if (mnemonic == null) mnemonic = yield* bip39.make;
+    const seed = yield* bip39.toSeed(mnemonic);
+    const id = yield* Effect.map(
+      slip21Derive(seed, ["Evolu", "Owner Id"]),
+      (key) => {
+        // convert key to nanoid
+        let id = "";
+        for (let i = 0; i < 21; i++) {
+          id += urlAlphabet[key[i] & 63];
+        }
+        return id as OwnerId;
+      },
     );
-
-    const encryptionKey = yield* _(
-      slip21Derive(seed, ["Evolu", "Encryption Key"]),
-    );
-
+    const encryptionKey = yield* slip21Derive(seed, [
+      "Evolu",
+      "Encryption Key",
+    ]);
     return { mnemonic, id, encryptionKey };
   });
+
+// From https://github.com/ai/nanoid/blob/main/url-alphabet/index.js
+// It's copy-pasted for now because NanoId import breaks Metro bundler.
+// https://github.com/ai/nanoid/issues/468
+const urlAlphabet =
+  "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";

package/src/Platform.ts

@@ -1,95 +1,47 @@
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import { Config } from "./Config.js";
 
 /**
- * FlushSync lets you force React to flush any updates inside the provided
- * callback synchronously. This ensures that the DOM is updated immediately.
+ * FlushSync is a service for libraries like React to synchronously flush
+ * updates inside the provided callback to ensure the DOM is updated
+ * immediately.
  *
- * It's required only for React DOM. The other UI libraries probably don't need
- * that, so it should be a no-op.
+ * https://react.dev/reference/react-dom/flushSync
  */
 export type FlushSync = (callback: () => void) => void;
+export const FlushSync = Context.GenericTag<FlushSync>("FlushSync");
+
+export class AppState extends Context.Tag("AppState")<
+  AppState,
+  {
+    readonly init: (options: {
+      readonly reloadUrl: string;
+      readonly onRequestSync: () => void;
+    }) => Effect.Effect<AppStateReset>;
+  }
+>() {}
 
-export const FlushSync = Context.GenericTag<FlushSync>("@services/FlushSync");
-
-export const FlushSyncDefaultLive = Layer.succeed(FlushSync, (callback) =>
-  callback(),
-);
-
-export interface SyncLock {
-  /**
-   * Try to acquire a sync lock. The caller must not call sync if a sync lock
-   * can't be acquired.
-   */
-  readonly acquire: Effect.Effect<boolean>;
-
-  /** Release a sync lock. */
-  readonly release: Effect.Effect<void>;
-}
-
-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,
-) => Effect.Effect<Response, FetchError>;
-
-export const Fetch = Context.GenericTag<Fetch>("@services/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";
+interface AppStateReset {
+  readonly reset: Effect.Effect<void>;
 }
 
-export const FetchLive = Layer.succeed(
-  Fetch,
-  Fetch.of((url, body) =>
-    Effect.tryPromise({
-      try: () =>
-        fetch(url, {
-          method: "POST",
-          body,
-          headers: {
-            "Content-Type": "application/x-protobuf",
-            "Content-Length": body.length.toString(),
-          },
-        }),
-      catch: (): FetchError => ({ _tag: "FetchError" }),
-    }),
-  ),
-);
+export class SyncLock extends Context.Tag("SyncLock")<
+  SyncLock,
+  {
+    readonly tryAcquire: Effect.Effect<
+      SyncLockRelease,
+      SyncLockAlreadySyncingError,
+      Config | Scope.Scope
+    >;
+  }
+>() {}
 
-interface AppStateConfig {
-  readonly onRequestSync: () => void;
+export interface SyncLockRelease {
+  readonly release: Effect.Effect<void>;
 }
 
-export interface AppState {
-  readonly init: (config: AppStateConfig) => void;
-  readonly reset: Effect.Effect<void>;
+export class SyncLockAlreadySyncingError {
+  readonly _tag = "SyncLockAlreadySyncingError";
 }
-
-export const AppState = Context.GenericTag<AppState>("@services/AppState");
-
-/** To detect whether DOM can be used. */
-export const canUseDom = ((): boolean => {
-  // IDK why try-catch is necessary, but it is.
-  // "ReferenceError: window is not defined" should not happen, but it does.
-  try {
-    return !!(
-      typeof window !== "undefined" &&
-      window.document &&
-      window.document.createElement
-    );
-  } catch (e) {
-    return false;
-  }
-})();

package/src/Public.ts

@@ -3,11 +3,9 @@ export type { NotNull } from "kysely";
 export { jsonArrayFrom, jsonObjectFrom } from "kysely/helpers/sqlite";
 export type { Timestamp, TimestampError } from "./Crdt.js";
 export type { InvalidMnemonicError, Mnemonic } from "./Crypto.js";
-export { database, table } from "./Db.js";
 export type { ExtractRow, QueryResult } from "./Db.js";
-export type { EvoluError, UnexpectedError } from "./ErrorStore.js";
-export { createIndex } from "./Evolu.js";
+export * from "./Error.js";
+export { createIndexes } from "./Evolu.js";
 export * from "./Model.js";
 export type { Owner, OwnerId } from "./Owner.js";
-export { canUseDom } from "./Platform.js";
-export type { SyncState } from "./SyncWorker.js";
+export type { SyncState } from "./Sync.js";

package/src/Sqlite.ts

@@ -1,13 +1,81 @@
+import * as Console from "effect/Console";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import { Equivalence } from "effect/Equivalence";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
 import * as Predicate from "effect/Predicate";
+import { Config } from "./Config.js";
 
 export interface Sqlite {
   readonly exec: (query: SqliteQuery) => Effect.Effect<SqliteExecResult>;
+  readonly transaction: (
+    /**
+     * Use `exclusive` for mutations and `shared` for read-only queries. This
+     * shared/exclusive lock pattern allows multiple simultaneous readers but
+     * only one writer. In Evolu, this pattern also ensures that every write can
+     * be immediately read without waiting to complete. For example, we can add
+     * data on one page and then immediately redirect to another, and the data
+     * will be there.
+     *
+     * There is also a `last` mode that ensures no other transaction can run.
+     * It's for Db reset to ensure no data are accidentally saved after database
+     * wipe-out.
+     */
+    mode: SqliteTransactionMode,
+  ) => <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, E, Sqlite | R>;
 }
 
-export const Sqlite = Context.GenericTag<Sqlite>("@services/Sqlite");
+export const Sqlite = Context.GenericTag<Sqlite>("Sqlite");
+
+export type SqliteTransactionMode = "exclusive" | "shared" | "last";
+
+export class SqliteFactory extends Context.Tag("SqliteFactory")<
+  SqliteFactory,
+  {
+    readonly createSqlite: Effect.Effect<Sqlite, never, Config>;
+  }
+>() {
+  static Common = Layer.effect(
+    SqliteFactory,
+    Effect.map(SqliteFactory, (platformSqliteFactory) => ({
+      createSqlite: Effect.logTrace("SqliteFactory createSqlite").pipe(
+        Effect.zipRight(platformSqliteFactory.createSqlite),
+        Effect.map(
+          (platformSqlite): Sqlite => ({
+            exec: (query) =>
+              platformSqlite.exec(query).pipe(
+                Effect.tap((result) => {
+                  maybeParseJson(result.rows);
+                }),
+                Effect.tap((result) =>
+                  ["begin", "rollback", "commit"].includes(query.sql)
+                    ? Effect.logDebug(`SQLiteCommon ${query.sql} transaction`)
+                    : Effect.logDebug(["SQLiteCommon exec", query, result]),
+                ),
+              ),
+            transaction: (mode) => (effect) => {
+              // Shared is for readonly queries.
+              if (mode === "shared")
+                return platformSqlite.transaction(mode)(effect);
+              return Effect.flatMap(Sqlite, (sqlite) =>
+                Effect.acquireUseRelease(
+                  sqlite.exec({ sql: "begin" }),
+                  () => effect,
+                  (_, exit) =>
+                    Exit.isFailure(exit)
+                      ? sqlite.exec({ sql: "rollback" })
+                      : sqlite.exec({ sql: "commit" }),
+                ),
+              ).pipe(platformSqlite.transaction(mode));
+            },
+          }),
+        ),
+      ),
+    })),
+  );
+}
 
 export interface SqliteQuery {
   readonly sql: string;
@@ -49,8 +117,10 @@ export const valuesToSqliteValues = (
     isJsonObjectOrArray(value) ? JSON.stringify(value) : value,
   );
 
-export const maybeParseJson = (rows: SqliteRow[]): SqliteRow[] =>
+/** This function mutates for better performance. */
+export const maybeParseJson = (rows: SqliteRow[]): void => {
   parseArray(rows);
+};
 
 const parseArray = <T>(a: T[]): T[] => {
   for (let i = 0; i < a.length; ++i) a[i] = parse(a[i]) as T;
@@ -104,12 +174,14 @@ export const maybeLogSqliteQueryExecutionTime =
   (query: SqliteQuery) =>
   <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => {
     if (!query.options?.logQueryExecutionTime) return effect;
-    return effect.pipe(
-      Effect.tap(() => Effect.log("QueryExecutionTime")),
-      // Not using Effect.log because of formating
-      // eslint-disable-next-line no-console
-      Effect.tap(() => console.log(query.sql)),
-      Effect.withLogSpan("duration"),
+    return Effect.Do.pipe(
+      Effect.let("start", () => performance.now()),
+      Effect.bind("result", () => effect),
+      Effect.let("elapsed", ({ start }) => performance.now() - start),
+      Effect.tap(({ elapsed }) =>
+        Console.log(`QueryExecutionTime: ${elapsed}ms`, query),
+      ),
+      Effect.map(({ result }) => result),
     );
   };
 
@@ -136,21 +208,3 @@ export const drawSqliteQueryPlan = (rows: SqliteQueryPlanRow[]): string =>
       return `${"  ".repeat(indent)}${row.detail}`;
     })
     .join("\n");
-
-export interface SqliteSchema {
-  readonly tables: ReadonlyArray<Table>;
-  readonly indexes: ReadonlyArray<Index>;
-}
-
-export interface Table {
-  readonly name: string;
-  readonly columns: ReadonlyArray<string>;
-}
-
-export interface Index {
-  readonly name: string;
-  readonly sql: string;
-}
-
-export const indexEquivalence: Equivalence<Index> = (self, that) =>
-  self.name === that.name && self.sql === that.sql;