@evolu/react-native 8.0.0 → 9.0.0

package/dist/PlatformLive.d.ts

@@ -1,7 +1,6 @@
-import { AppState, Bip39, DbWorkerLock, SyncLock } from "@evolu/common";
+import { AppState, Bip39, SyncLock } from "@evolu/common";
 import * as Layer from "effect/Layer";
-export declare const SyncLockLive: Layer.Layer<SyncLock, never, never>;
-export declare const DbWorkerLockLive: Layer.Layer<DbWorkerLock, never, never>;
 export declare const AppStateLive: Layer.Layer<AppState, never, never>;
+export declare const SyncLockLive: Layer.Layer<SyncLock, never, never>;
 export declare const Bip39Live: Layer.Layer<Bip39, never, never>;
 //# sourceMappingURL=PlatformLive.d.ts.map

package/dist/PlatformLive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PlatformLive.d.ts","sourceRoot":"","sources":["../src/PlatformLive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,KAAK,EACL,YAAY,EAGZ,QAAQ,EACT,MAAM,eAAe,CAAC;AASvB,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAItC,eAAO,MAAM,YAAY,qCAexB,CAAC;AAEF,eAAO,MAAM,gBAAgB,yCAQ5B,CAAC;AAEF,eAAO,MAAM,YAAY,qCA4BxB,CAAC;AAEF,eAAO,MAAM,SAAS,kCAYrB,CAAC"}
+{"version":3,"file":"PlatformLive.d.ts","sourceRoot":"","sources":["../src/PlatformLive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,KAAK,EAEL,QAAQ,EAIT,MAAM,eAAe,CAAC;AASvB,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAItC,eAAO,MAAM,YAAY,qCAmCxB,CAAC;AAEF,eAAO,MAAM,YAAY,qCA2BxB,CAAC;AAEF,eAAO,MAAM,SAAS,kCAUrB,CAAC"}

package/dist/PlatformLive.js

@@ -1,4 +1,4 @@
-import { AppState, Bip39, DbWorkerLock, SyncLock, } from "@evolu/common";
+import { AppState, Bip39, SyncLock, SyncLockAlreadySyncingError, validateMnemonicToEffect, } from "@evolu/common";
 import NetInfo from "@react-native-community/netinfo";
 import { generateMnemonic, mnemonicToSeed, validateMnemonic, } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
@@ -6,31 +6,12 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { reloadAsync } from "expo-updates";
 import { DevSettings, AppState as ReactNativeAppState } from "react-native";
-export const SyncLockLive = Layer.effect(SyncLock, Effect.sync(() => {
-    let hasSyncLock = false;
-    return SyncLock.of({
-        acquire: Effect.sync(() => {
-            if (hasSyncLock)
-                return false;
-            hasSyncLock = true;
-            return true;
-        }),
-        release: Effect.sync(() => {
-            hasSyncLock = false;
-        }),
-    });
-}));
-export const DbWorkerLockLive = Layer.effect(DbWorkerLock, Effect.sync(() => {
-    let queue = Promise.resolve(undefined);
-    return DbWorkerLock.of((callback) => {
-        queue = queue.then(callback);
-    });
-}));
 export const AppStateLive = Layer.succeed(AppState, AppState.of({
-    init: ({ onRequestSync }) => {
+    init: ({ onRequestSync }) => Effect.sync(() => {
         let appStateStatus = ReactNativeAppState.currentState;
         ReactNativeAppState.addEventListener("change", (current) => {
-            if (appStateStatus.match(/inactive|background/) && current === "active")
+            if (appStateStatus.match(/inactive|background/) &&
+                current === "active")
                 onRequestSync();
             appStateStatus = current;
         });
@@ -42,18 +23,41 @@ export const AppStateLive = Layer.succeed(AppState, AppState.of({
                 onRequestSync();
             netInfoState = current;
         });
-    },
-    reset: Effect.sync(() => {
-        if (process.env.NODE_ENV === "development")
-            DevSettings.reload();
-        else
-            reloadAsync();
+        const reset = process.env.NODE_ENV === "development"
+            ? Effect.sync(() => {
+                DevSettings.reload();
+            })
+            : Effect.promise(() => reloadAsync());
+        return { reset };
     }),
 }));
+export const SyncLockLive = Layer.effect(SyncLock, Effect.sync(() => {
+    let hasSyncLock = false;
+    return SyncLock.of({
+        tryAcquire: Effect.gen(function* () {
+            yield* Effect.logTrace("SyncLock tryAcquire");
+            const acquire = Effect.gen(function* () {
+                if (hasSyncLock) {
+                    yield* Effect.logTrace("SyncLock not acquired");
+                    yield* Effect.fail(new SyncLockAlreadySyncingError());
+                }
+                yield* Effect.logTrace("SyncLock acquired");
+                hasSyncLock = true;
+                const syncLockRelease = {
+                    release: Effect.gen(function* () {
+                        yield* Effect.logTrace("SyncLock released");
+                        hasSyncLock = false;
+                    }),
+                };
+                return syncLockRelease;
+            });
+            const release = ({ release }) => release;
+            return yield* Effect.acquireRelease(acquire, release);
+        }),
+    });
+}));
 export const Bip39Live = Layer.succeed(Bip39, Bip39.of({
     make: Effect.sync(() => generateMnemonic(wordlist, 128)),
     toSeed: (mnemonic) => Effect.promise(() => mnemonicToSeed(mnemonic)),
-    parse: (mnemonic) => validateMnemonic(mnemonic, wordlist)
-        ? Effect.succeed(mnemonic)
-        : Effect.fail({ _tag: "InvalidMnemonicError" }),
+    parse: (mnemonic) => validateMnemonicToEffect(validateMnemonic)(mnemonic, wordlist),
 }));

package/dist/SqliteLive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SqliteLive.d.ts","sourceRoot":"","sources":["../src/SqliteLive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,MAAM,EAMP,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,eAAO,MAAM,UAAU,oCA0BtB,CAAC"}
+{"version":3,"file":"SqliteLive.d.ts","sourceRoot":"","sources":["../src/SqliteLive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,MAAM,EAKP,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,eAAO,MAAM,UAAU,oCA0BtB,CAAC"}

package/dist/SqliteLive.js

@@ -1,20 +1,22 @@
-import { Config, Sqlite, isSqlMutation, maybeLogSqliteQueryExecutionTime, maybeParseJson, valuesToSqliteValues, } from "@evolu/common";
+import { Config, Sqlite, isSqlMutation, maybeLogSqliteQueryExecutionTime, valuesToSqliteValues, } from "@evolu/common";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as ExpoSQLite from "expo-sqlite/next";
-export const SqliteLive = Layer.effect(Sqlite, Effect.gen(function* (_) {
-    const config = yield* _(Config);
+export const SqliteLive = Layer.effect(Sqlite, Effect.gen(function* () {
+    const config = yield* Config;
     const db = ExpoSQLite.openDatabaseSync(`evolu1-${config.name}.db`);
+    const mutex = yield* Effect.makeSemaphore(1);
     return Sqlite.of({
-        exec: (query) => Effect.gen(function* (_) {
+        exec: (query) => Effect.gen(function* () {
             const parameters = valuesToSqliteValues(query.parameters || []);
             if (!isSqlMutation(query.sql)) {
-                const rows = (yield* _(Effect.promise(() => db.getAllAsync(query.sql, parameters)), maybeLogSqliteQueryExecutionTime(query)));
-                maybeParseJson(rows);
+                const rows = (yield* Effect.promise(() => db.getAllAsync(query.sql, parameters)).pipe(maybeLogSqliteQueryExecutionTime(query)));
                 return { rows, changes: 0 };
             }
-            const { changes } = yield* _(Effect.promise(() => db.runAsync(query.sql, parameters)));
+            const { changes } = yield* Effect.promise(() => db.runAsync(query.sql, parameters));
             return { rows: [], changes };
         }),
+        // RN doesn't need the "last" mode because there are no tabs.
+        transaction: () => mutex.withPermits(1),
     });
 }));

package/dist/index.d.ts

@@ -1,39 +1,40 @@
-import { InvalidMnemonicError, Mnemonic } from "@evolu/common";
+import { EvoluFactory, InvalidMnemonicError, Mnemonic } from "@evolu/common";
 import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 export * from "@evolu/common/public";
 /** Parse a string to {@link Mnemonic}. */
 export declare const parseMnemonic: (mnemonic: string) => Effect.Effect<Mnemonic, InvalidMnemonicError>;
+export declare const EvoluFactoryReactNative: Layer.Layer<EvoluFactory, never, never>;
+export declare const 
 /**
- * Create Evolu for React Native.
+ * Create Evolu from the database schema.
  *
  * Tables with a name prefixed with `_` are local-only, which means they are
  * never synced. It's useful for device-specific or temporal data.
  *
  * @example
  *   import * as S from "@effect/schema/Schema";
- *   import {
- *     NonEmptyString1000,
- *     createEvolu,
- *     id,
- *   } from "@evolu/react-native";
+ *   import * as E from "@evolu/react-native";
  *
- *   const TodoId = id("Todo");
+ *   const TodoId = E.id("Todo");
  *   type TodoId = S.Schema.Type<typeof TodoId>;
  *
- *   const TodoTable = table({
+ *   const TodoTable = E.table({
  *     id: TodoId,
- *     title: NonEmptyString1000,
+ *     title: E.NonEmptyString1000,
  *   });
  *   type TodoTable = S.Schema.Type<typeof TodoTable>;
  *
- *   const Database = database({
- *     // _todo is local-only table
+ *   const Database = E.database({
  *     todo: TodoTable,
+ *
+ *     // Prefix `_` makes the table local-only (it will not sync)
+ *     _todo: TodoTable,
  *   });
  *   type Database = S.Schema.Type<typeof Database>;
  *
- *   const evolu = createEvolu(Database);
+ *   const evolu = E.createEvolu(Database);
  */
-export declare const createEvolu: <From, To extends import("@evolu/common").DatabaseSchema>(schema: import("@effect/schema/Schema").Schema<To, From, never>, config?: Partial<import("@evolu/common").Config> | undefined) => import("@evolu/common").Evolu<To>;
+createEvolu: <T extends import("@evolu/common").EvoluSchema, I>(schema: import("@effect/schema/Schema").Schema<T, I, never>, config?: Partial<import("@evolu/common").EvoluConfig<T>> | undefined) => import("@evolu/common").Evolu<T>;
 export * from "@evolu/common-react";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,oBAAoB,EACpB,QAAQ,EAKT,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAUxC,cAAc,sBAAsB,CAAC;AAErC,0CAA0C;AAC1C,eAAO,MAAM,aAAa,EAAE,CAC1B,QAAQ,EAAE,MAAM,KACb,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,oBAAoB,CAG1C,CAAC;AAER;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,WAAW,+NAgBvB,CAAC;AAEF,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,YAAY,EACZ,oBAAoB,EACpB,QAAQ,EAST,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAStC,cAAc,sBAAsB,CAAC;AAErC,0CAA0C;AAC1C,eAAO,MAAM,aAAa,EAAE,CAC1B,QAAQ,EAAE,MAAM,KACb,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,oBAAoB,CAG1C,CAAC;AAUR,eAAO,MAAM,uBAAuB,yCAuBnC,CAAC;AAKF,eAAO;AACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,WAAW,2NACiE,CAAC;AAE/E,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -1,41 +1,56 @@
-import { Bip39, DbWorkerCommonLive, EvoluCommonLive, FetchLive, FlushSyncDefaultLive, NanoIdGeneratorLive, SecretBoxLive, SyncWorkerCommonLive, makeCreateEvolu, } from "@evolu/common";
+import { Bip39, DbFactory, EvoluFactory, SecretBox, Sqlite, SqliteFactory, SyncFactory, Time, createDb, createNanoIdGeneratorLive, createSync, } from "@evolu/common";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { AppStateLive, Bip39Live, DbWorkerLockLive, SyncLockLive, } from "./PlatformLive.js";
+// @ts-expect-error https://github.com/ai/nanoid/issues/468
+import { customAlphabet, nanoid } from "nanoid/index.browser.js";
+import { AppStateLive, Bip39Live, SyncLockLive } from "./PlatformLive.js";
 import { SqliteLive } from "./SqliteLive.js";
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+const NanoIdGeneratorLive = createNanoIdGeneratorLive(customAlphabet, nanoid);
 export * from "@evolu/common/public";
 /** Parse a string to {@link Mnemonic}. */
 export const parseMnemonic = Bip39.pipe(Effect.provide(Bip39Live), Effect.runSync).parse;
+const SyncFactoryLive = Layer.succeed(SyncFactory, {
+    createSync: Effect.provide(createSync, SecretBox.Live),
+});
+const SqliteFactoryLive = Layer.succeed(SqliteFactory, {
+    createSqlite: Sqlite.pipe(Effect.provide(SqliteLive)),
+});
+export const EvoluFactoryReactNative = Layer.provide(EvoluFactory.Common, Layer.mergeAll(Layer.succeed(DbFactory, {
+    createDb: createDb.pipe(Effect.provide(Layer.mergeAll(Bip39Live, SqliteFactory.Common.pipe(Layer.provide(SqliteFactoryLive), Layer.provide(NanoIdGeneratorLive)), NanoIdGeneratorLive, Time.Live, SyncFactoryLive, SyncLockLive))),
+}), NanoIdGeneratorLive, AppStateLive));
+// JSDoc doesn't support destructured parameters, so we must copy-paste
+// createEvolu docs from `evolu-common/src/Evolu.ts`.
+// https://github.com/microsoft/TypeScript/issues/11859
+export const { 
 /**
- * Create Evolu for React Native.
+ * Create Evolu from the database schema.
  *
  * Tables with a name prefixed with `_` are local-only, which means they are
  * never synced. It's useful for device-specific or temporal data.
  *
  * @example
  *   import * as S from "@effect/schema/Schema";
- *   import {
- *     NonEmptyString1000,
- *     createEvolu,
- *     id,
- *   } from "@evolu/react-native";
+ *   import * as E from "@evolu/react-native";
  *
- *   const TodoId = id("Todo");
+ *   const TodoId = E.id("Todo");
  *   type TodoId = S.Schema.Type<typeof TodoId>;
  *
- *   const TodoTable = table({
+ *   const TodoTable = E.table({
  *     id: TodoId,
- *     title: NonEmptyString1000,
+ *     title: E.NonEmptyString1000,
  *   });
  *   type TodoTable = S.Schema.Type<typeof TodoTable>;
  *
- *   const Database = database({
- *     // _todo is local-only table
+ *   const Database = E.database({
  *     todo: TodoTable,
+ *
+ *     // Prefix `_` makes the table local-only (it will not sync)
+ *     _todo: TodoTable,
  *   });
  *   type Database = S.Schema.Type<typeof Database>;
  *
- *   const evolu = createEvolu(Database);
+ *   const evolu = E.createEvolu(Database);
  */
-export const createEvolu = makeCreateEvolu(EvoluCommonLive.pipe(Layer.provide(Layer.mergeAll(FlushSyncDefaultLive, AppStateLive, DbWorkerCommonLive)), Layer.provide(Layer.mergeAll(Bip39Live, NanoIdGeneratorLive, SqliteLive, SyncWorkerCommonLive, DbWorkerLockLive)), Layer.provide(Layer.mergeAll(SecretBoxLive, SyncLockLive, FetchLive))));
+createEvolu, } = EvoluFactory.pipe(Effect.provide(EvoluFactoryReactNative), Effect.runSync);
 export * from "@evolu/common-react";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/react-native",
-  "version": "8.0.0",
+  "version": "9.0.0",
   "description": "Evolu for React Native",
   "keywords": [
     "evolu",
@@ -31,25 +31,25 @@
     "README.md"
   ],
   "dependencies": {
-    "expo-updates": "^0.24.11"
+    "expo-updates": "^0.24.12"
   },
   "devDependencies": {
     "eslint": "^8.57.0",
-    "expo": "^50.0.14",
+    "expo": "^50.0.17",
     "expo-sqlite": "~13.4.0",
     "react-native": "0.73.6",
-    "typescript": "^5.4.3",
-    "vitest": "^1.4.0",
-    "@evolu/common": "4.1.0",
-    "@evolu/common-react": "7.0.0",
+    "typescript": "^5.4.5",
+    "vitest": "^1.5.2",
+    "@evolu/common": "5.0.0",
+    "@evolu/common-react": "8.0.0",
     "@evolu/tsconfig": "0.0.2",
     "eslint-config-evolu": "1.0.0"
   },
   "peerDependencies": {
-    "@evolu/common-react": "^7.0.0",
+    "@evolu/common-react": "^8.0.0",
     "expo": "^50.0.14",
     "expo-sqlite": "~13.4.0",
-    "react-native": "0.73.6"
+    "react-native": "^0.73.6"
   },
   "publishConfig": {
     "access": "public"

package/src/PlatformLive.ts

@@ -1,10 +1,11 @@
 import {
   AppState,
   Bip39,
-  DbWorkerLock,
-  InvalidMnemonicError,
   Mnemonic,
   SyncLock,
+  SyncLockAlreadySyncingError,
+  SyncLockRelease,
+  validateMnemonicToEffect,
 } from "@evolu/common";
 import NetInfo, { NetInfoState } from "@react-native-community/netinfo";
 import {
@@ -18,63 +19,72 @@ import * as Layer from "effect/Layer";
 import { reloadAsync } from "expo-updates";
 import { DevSettings, AppState as ReactNativeAppState } from "react-native";
 
+export const AppStateLive = Layer.succeed(
+  AppState,
+  AppState.of({
+    init: ({ onRequestSync }) =>
+      Effect.sync(() => {
+        let appStateStatus = ReactNativeAppState.currentState;
+        ReactNativeAppState.addEventListener("change", (current) => {
+          if (
+            appStateStatus.match(/inactive|background/) &&
+            current === "active"
+          )
+            onRequestSync();
+          appStateStatus = current;
+        });
+
+        let netInfoState: NetInfoState | null = null;
+        NetInfo.addEventListener((current) => {
+          if (
+            netInfoState?.isInternetReachable === false &&
+            current.isConnected &&
+            current.isInternetReachable
+          )
+            onRequestSync();
+          netInfoState = current;
+        });
+
+        const reset =
+          process.env.NODE_ENV === "development"
+            ? Effect.sync(() => {
+                DevSettings.reload();
+              })
+            : Effect.promise(() => reloadAsync());
+        return { reset };
+      }),
+  }),
+);
+
 export const SyncLockLive = Layer.effect(
   SyncLock,
   Effect.sync(() => {
     let hasSyncLock = false;
     return SyncLock.of({
-      acquire: Effect.sync(() => {
-        if (hasSyncLock) return false;
-        hasSyncLock = true;
-        return true;
-      }),
-      release: Effect.sync(() => {
-        hasSyncLock = false;
+      tryAcquire: Effect.gen(function* () {
+        yield* Effect.logTrace("SyncLock tryAcquire");
+        const acquire = Effect.gen(function* () {
+          if (hasSyncLock) {
+            yield* Effect.logTrace("SyncLock not acquired");
+            yield* Effect.fail(new SyncLockAlreadySyncingError());
+          }
+          yield* Effect.logTrace("SyncLock acquired");
+          hasSyncLock = true;
+          const syncLockRelease: SyncLockRelease = {
+            release: Effect.gen(function* () {
+              yield* Effect.logTrace("SyncLock released");
+              hasSyncLock = false;
+            }),
+          };
+          return syncLockRelease;
+        });
+        const release = ({ release }: SyncLockRelease) => release;
+        return yield* Effect.acquireRelease(acquire, release);
       }),
     });
   }),
 );
 
-export const DbWorkerLockLive = Layer.effect(
-  DbWorkerLock,
-  Effect.sync(() => {
-    let queue: Promise<void> = Promise.resolve(undefined);
-    return DbWorkerLock.of((callback) => {
-      queue = queue.then(callback);
-    });
-  }),
-);
-
-export const AppStateLive = Layer.succeed(
-  AppState,
-  AppState.of({
-    init: ({ onRequestSync }) => {
-      let appStateStatus = ReactNativeAppState.currentState;
-      ReactNativeAppState.addEventListener("change", (current): void => {
-        if (appStateStatus.match(/inactive|background/) && current === "active")
-          onRequestSync();
-        appStateStatus = current;
-      });
-
-      let netInfoState: NetInfoState | null = null;
-      NetInfo.addEventListener((current) => {
-        if (
-          netInfoState?.isInternetReachable === false &&
-          current.isConnected &&
-          current.isInternetReachable
-        )
-          onRequestSync();
-        netInfoState = current;
-      });
-    },
-
-    reset: Effect.sync(() => {
-      if (process.env.NODE_ENV === "development") DevSettings.reload();
-      else reloadAsync();
-    }),
-  }),
-);
-
 export const Bip39Live = Layer.succeed(
   Bip39,
   Bip39.of({
@@ -83,8 +93,6 @@ export const Bip39Live = Layer.succeed(
     toSeed: (mnemonic) => Effect.promise(() => mnemonicToSeed(mnemonic)),
 
     parse: (mnemonic) =>
-      validateMnemonic(mnemonic, wordlist)
-        ? Effect.succeed(mnemonic as Mnemonic)
-        : Effect.fail<InvalidMnemonicError>({ _tag: "InvalidMnemonicError" }),
+      validateMnemonicToEffect(validateMnemonic)(mnemonic, wordlist),
   }),
 );

package/src/SqliteLive.ts

@@ -4,7 +4,6 @@ import {
   SqliteRow,
   isSqlMutation,
   maybeLogSqliteQueryExecutionTime,
-  maybeParseJson,
   valuesToSqliteValues,
 } from "@evolu/common";
 import * as Effect from "effect/Effect";
@@ -13,28 +12,28 @@ import * as ExpoSQLite from "expo-sqlite/next";
 
 export const SqliteLive = Layer.effect(
   Sqlite,
-  Effect.gen(function* (_) {
-    const config = yield* _(Config);
+  Effect.gen(function* () {
+    const config = yield* Config;
     const db = ExpoSQLite.openDatabaseSync(`evolu1-${config.name}.db`);
+    const mutex = yield* Effect.makeSemaphore(1);
 
     return Sqlite.of({
       exec: (query) =>
-        Effect.gen(function* (_) {
+        Effect.gen(function* () {
           const parameters = valuesToSqliteValues(query.parameters || []);
-
           if (!isSqlMutation(query.sql)) {
-            const rows = (yield* _(
-              Effect.promise(() => db.getAllAsync(query.sql, parameters)),
-              maybeLogSqliteQueryExecutionTime(query),
-            )) as SqliteRow[];
-            maybeParseJson(rows);
+            const rows = (yield* Effect.promise(() =>
+              db.getAllAsync(query.sql, parameters),
+            ).pipe(maybeLogSqliteQueryExecutionTime(query))) as SqliteRow[];
             return { rows, changes: 0 };
           }
-          const { changes } = yield* _(
-            Effect.promise(() => db.runAsync(query.sql, parameters)),
+          const { changes } = yield* Effect.promise(() =>
+            db.runAsync(query.sql, parameters),
           );
           return { rows: [], changes };
         }),
+      // RN doesn't need the "last" mode because there are no tabs.
+      transaction: () => mutex.withPermits(1),
     });
   }),
 );

package/src/index.ts

@@ -1,26 +1,28 @@
 import {
   Bip39,
-  DbWorkerCommonLive,
-  EvoluCommonLive,
-  FetchLive,
-  FlushSyncDefaultLive,
+  DbFactory,
+  EvoluFactory,
   InvalidMnemonicError,
   Mnemonic,
-  NanoIdGeneratorLive,
-  SecretBoxLive,
-  SyncWorkerCommonLive,
-  makeCreateEvolu,
+  SecretBox,
+  Sqlite,
+  SqliteFactory,
+  SyncFactory,
+  Time,
+  createDb,
+  createNanoIdGeneratorLive,
+  createSync,
 } from "@evolu/common";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import {
-  AppStateLive,
-  Bip39Live,
-  DbWorkerLockLive,
-  SyncLockLive,
-} from "./PlatformLive.js";
+// @ts-expect-error https://github.com/ai/nanoid/issues/468
+import { customAlphabet, nanoid } from "nanoid/index.browser.js";
+import { AppStateLive, Bip39Live, SyncLockLive } from "./PlatformLive.js";
 import { SqliteLive } from "./SqliteLive.js";
 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+const NanoIdGeneratorLive = createNanoIdGeneratorLive(customAlphabet, nanoid);
+
 export * from "@evolu/common/public";
 
 /** Parse a string to {@link Mnemonic}. */
@@ -31,53 +33,73 @@ export const parseMnemonic: (
   Effect.runSync,
 ).parse;
 
-/**
- * Create Evolu for React Native.
- *
- * Tables with a name prefixed with `_` are local-only, which means they are
- * never synced. It's useful for device-specific or temporal data.
- *
- * @example
- *   import * as S from "@effect/schema/Schema";
- *   import {
- *     NonEmptyString1000,
- *     createEvolu,
- *     id,
- *   } from "@evolu/react-native";
- *
- *   const TodoId = id("Todo");
- *   type TodoId = S.Schema.Type<typeof TodoId>;
- *
- *   const TodoTable = table({
- *     id: TodoId,
- *     title: NonEmptyString1000,
- *   });
- *   type TodoTable = S.Schema.Type<typeof TodoTable>;
- *
- *   const Database = database({
- *     // _todo is local-only table
- *     todo: TodoTable,
- *   });
- *   type Database = S.Schema.Type<typeof Database>;
- *
- *   const evolu = createEvolu(Database);
- */
-export const createEvolu = makeCreateEvolu(
-  EvoluCommonLive.pipe(
-    Layer.provide(
-      Layer.mergeAll(FlushSyncDefaultLive, AppStateLive, DbWorkerCommonLive),
-    ),
-    Layer.provide(
-      Layer.mergeAll(
-        Bip39Live,
-        NanoIdGeneratorLive,
-        SqliteLive,
-        SyncWorkerCommonLive,
-        DbWorkerLockLive,
+const SyncFactoryLive = Layer.succeed(SyncFactory, {
+  createSync: Effect.provide(createSync, SecretBox.Live),
+});
+
+const SqliteFactoryLive = Layer.succeed(SqliteFactory, {
+  createSqlite: Sqlite.pipe(Effect.provide(SqliteLive)),
+});
+
+export const EvoluFactoryReactNative = Layer.provide(
+  EvoluFactory.Common,
+  Layer.mergeAll(
+    Layer.succeed(DbFactory, {
+      createDb: createDb.pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            Bip39Live,
+            SqliteFactory.Common.pipe(
+              Layer.provide(SqliteFactoryLive),
+              Layer.provide(NanoIdGeneratorLive),
+            ),
+            NanoIdGeneratorLive,
+            Time.Live,
+            SyncFactoryLive,
+            SyncLockLive,
+          ),
+        ),
       ),
-    ),
-    Layer.provide(Layer.mergeAll(SecretBoxLive, SyncLockLive, FetchLive)),
+    }),
+    NanoIdGeneratorLive,
+    AppStateLive,
   ),
 );
 
+// JSDoc doesn't support destructured parameters, so we must copy-paste
+// createEvolu docs from `evolu-common/src/Evolu.ts`.
+// https://github.com/microsoft/TypeScript/issues/11859
+export const {
+  /**
+   * Create Evolu from the database schema.
+   *
+   * Tables with a name prefixed with `_` are local-only, which means they are
+   * never synced. It's useful for device-specific or temporal data.
+   *
+   * @example
+   *   import * as S from "@effect/schema/Schema";
+   *   import * as E from "@evolu/react-native";
+   *
+   *   const TodoId = E.id("Todo");
+   *   type TodoId = S.Schema.Type<typeof TodoId>;
+   *
+   *   const TodoTable = E.table({
+   *     id: TodoId,
+   *     title: E.NonEmptyString1000,
+   *   });
+   *   type TodoTable = S.Schema.Type<typeof TodoTable>;
+   *
+   *   const Database = E.database({
+   *     todo: TodoTable,
+   *
+   *     // Prefix `_` makes the table local-only (it will not sync)
+   *     _todo: TodoTable,
+   *   });
+   *   type Database = S.Schema.Type<typeof Database>;
+   *
+   *   const evolu = E.createEvolu(Database);
+   */
+  createEvolu,
+} = EvoluFactory.pipe(Effect.provide(EvoluFactoryReactNative), Effect.runSync);
+
 export * from "@evolu/common-react";