@evolu/common 1.0.17 → 2.0.1

package/src/Sqlite.ts

@@ -1,45 +1,37 @@
-import { Brand, Context, Effect, Predicate, ReadonlyRecord } from "effect";
+import { Context, Effect, Predicate, ReadonlyRecord } from "effect";
 
 export interface Sqlite {
   readonly exec: (
-    arg: string | QueryObject,
+    arg: string | SqliteQuery,
   ) => Effect.Effect<never, never, ExecResult>;
 }
 
-export const Sqlite = Context.Tag<Sqlite>("evolu/Sqlite");
+export const Sqlite = Context.Tag<Sqlite>();
 
-export interface QueryObject {
+export interface SqliteQuery {
   readonly sql: string;
-  readonly parameters: ReadonlyArray<Value>;
+  readonly parameters: Value[];
 }
 
 export type Value = SqliteValue | JsonObjectOrArray;
-
 export type SqliteValue = null | string | number | Uint8Array;
-export type SqliteRow = Record<string, SqliteValue>;
-
 export type JsonObjectOrArray = JsonObject | JsonArray;
-
 type JsonObject = ReadonlyRecord.ReadonlyRecord<Json>;
 type JsonArray = ReadonlyArray<Json>;
 type Json = string | number | boolean | null | JsonObject | JsonArray;
 
 interface ExecResult {
-  readonly rows: ReadonlyArray<Row>;
+  readonly rows: SqliteRow[];
   readonly changes: number;
 }
 
-export type Row = ReadonlyRecord.ReadonlyRecord<
-  Value | Row | ReadonlyArray<Row>
->;
-
-export type Query = string & Brand.Brand<"Query">;
+export type SqliteRow = Record<string, SqliteValue>;
 
 export const isJsonObjectOrArray: Predicate.Refinement<
   Value,
   JsonObjectOrArray
 > = (value): value is JsonObjectOrArray =>
-  value !== null && typeof value === "object" && !(value instanceof Uint8Array);
+  value !== null && typeof value === "object" && !Predicate.isUint8Array(value);
 
 export const valuesToSqliteValues = (
   values: ReadonlyArray<Value>,
@@ -48,15 +40,13 @@ export const valuesToSqliteValues = (
     isJsonObjectOrArray(value) ? JSON.stringify(value) : value,
   );
 
-export const queryObjectToQuery = ({ sql, parameters }: QueryObject): Query =>
-  JSON.stringify({ sql, parameters }) as Query;
-
-export const queryObjectFromQuery = (s: Query): QueryObject =>
-  JSON.parse(s) as QueryObject;
+export const ensureSqliteQuery = (arg: string | SqliteQuery): SqliteQuery => {
+  if (typeof arg !== "string") return arg;
+  return { sql: arg, parameters: [] };
+};
 
-export const parseJsonResults = (rows: SqliteRow[]): void => {
+export const maybeParseJson = (rows: SqliteRow[]): SqliteRow[] =>
   parseArray(rows);
-};
 
 const parseArray = <T>(a: T[]): T[] => {
   for (let i = 0; i < a.length; ++i) a[i] = parse(a[i]) as T;
@@ -67,7 +57,6 @@ const parse = (o: unknown): unknown => {
   if (Predicate.isString(o)) return parseString(o);
   // eslint-disable-next-line @typescript-eslint/no-unsafe-return
   if (Array.isArray(o)) return parseArray(o);
-  // Predicate.isReadonlyRecord
   if (typeof o === "object" && o !== null && !Predicate.isUint8Array(o))
     return parseObject(o as Record<string, unknown>);
   return o;

package/src/Store.ts

@@ -1,32 +1,44 @@
-export type StoreListener = () => void;
+import { Effect } from "effect";
 
-export type StoreUnsubscribe = () => void;
+export type Listener = () => void;
+
+export type Unsubscribe = () => void;
 
 export interface Store<T> {
-  readonly subscribe: (listener: StoreListener) => StoreUnsubscribe;
-  readonly setState: (state: T) => void;
+  // No Effect API because of React useSyncExternalStore
+  readonly subscribe: (listener: Listener) => Unsubscribe;
   readonly getState: () => T;
-}
-
-export const makeStore = <T>(initialState: T): Store<T> => {
-  let currentState = initialState;
 
-  const listeners = new Set<StoreListener>();
+  // Effect API because it's a side-effect.
+  readonly setState: (state: T) => Effect.Effect<never, never, void>;
+}
 
-  const subscribe: Store<T>["subscribe"] = (listener) => {
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
+export const makeStore = <T>(
+  initialState: T,
+): Effect.Effect<never, never, Store<T>> =>
+  Effect.sync(() => {
+    const listeners = new Set<Listener>();
+    let currentState = initialState;
+
+    const store: Store<T> = {
+      subscribe(listener) {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      },
+
+      getState() {
+        return currentState;
+      },
+
+      setState: (state) =>
+        Effect.sync(() => {
+          if (state === currentState) return;
+          currentState = state;
+          listeners.forEach((listener) => listener());
+        }),
     };
-  };
-
-  const setState: Store<T>["setState"] = (state: T) => {
-    if (state === currentState) return;
-    currentState = state;
-    listeners.forEach((listener) => listener());
-  };
-
-  const getState: Store<T>["getState"] = () => currentState;
 
-  return { subscribe, setState, getState };
-};
+    return store;
+  });

package/src/SyncWorker.ts

@@ -6,6 +6,7 @@ import {
   Equivalence,
   Function,
   Layer,
+  Match,
   Option,
   Predicate,
   ReadonlyArray,
@@ -21,9 +22,9 @@ import {
   unsafeMerkleTreeFromString,
 } from "./Crdt.js";
 import { SecretBox } from "./Crypto.js";
-import { Owner } from "./Db.js";
-import { UnexpectedError, makeUnexpectedError } from "./Errors.js";
+import { UnexpectedError, makeUnexpectedError } from "./ErrorStore.js";
 import { Id } from "./Model.js";
+import { Owner } from "./Owner.js";
 import { Fetch, SyncLock } from "./Platform.js";
 import {
   EncryptedMessage,
@@ -38,13 +39,11 @@ export interface SyncWorker {
   onMessage: (output: SyncWorkerOutput) => void;
 }
 
-export const SyncWorker = Context.Tag<SyncWorker>("evolu/SyncWorker");
+export const SyncWorker = Context.Tag<SyncWorker>();
 
 export type SyncWorkerPostMessage = SyncWorker["postMessage"];
 
-export const SyncWorkerPostMessage = Context.Tag<SyncWorkerPostMessage>(
-  "evolu/SyncWorkerPostMessage",
-);
+export const SyncWorkerPostMessage = Context.Tag<SyncWorkerPostMessage>();
 
 export type SyncWorkerInput =
   | SyncWorkerInputSync
@@ -86,9 +85,7 @@ interface SyncWorkerInputSyncCompleted {
 
 type SyncWorkerOnMessage = SyncWorker["onMessage"];
 
-const SyncWorkerOnMessage = Context.Tag<SyncWorkerOnMessage>(
-  "evolu/SyncWorkerOnMessage",
-);
+const SyncWorkerOnMessage = Context.Tag<SyncWorkerOnMessage>();
 
 export type SyncWorkerOutput =
   | UnexpectedError
@@ -103,6 +100,12 @@ export type SyncWorkerOutputSyncResponse = {
   readonly syncLoopCount: number;
 };
 
+/**
+ * The SyncState type represents the various states that a synchronization
+ * process can be in. Evolu apps should not bother users with an "unsynced"
+ * state. Instead, they should warn users if data have not been synced for too
+ * long (a week, for example).
+ */
 export type SyncState =
   | SyncStateInitial
   | SyncStateIsSyncing
@@ -319,8 +322,6 @@ export const SyncWorkerLive = Layer.effect(
   SyncWorker,
   Effect.gen(function* (_) {
     const syncLock = yield* _(SyncLock);
-    const fetch = yield* _(Fetch);
-    const secretBox = yield* _(SecretBox);
 
     const onError = (
       error: UnexpectedError,
@@ -329,35 +330,26 @@ export const SyncWorkerLive = Layer.effect(
         syncWorker.onMessage(error);
       });
 
-    const mapInputToEffect = (
-      input: SyncWorkerInput,
-    ): Effect.Effect<
-      SyncLock | SyncWorkerOnMessage | Fetch | SecretBox,
-      never,
-      void
-    > => {
-      switch (input._tag) {
-        case "sync":
-          return sync(input);
-        case "syncCompleted":
-          return syncLock.release;
-      }
-    };
-
-    const postMessage: SyncWorker["postMessage"] = (input) => {
-      void mapInputToEffect(input).pipe(
-        Effect.catchAllDefect(makeUnexpectedError),
-        Effect.catchAll(onError),
-        Effect.provideService(SyncLock, syncLock),
-        Effect.provideService(Fetch, fetch),
-        Effect.provideService(SecretBox, secretBox),
-        Effect.provideService(SyncWorkerOnMessage, syncWorker.onMessage),
-        Effect.runPromise,
-      );
-    };
+    const context = Context.empty().pipe(
+      Context.add(SyncLock, syncLock),
+      Context.add(Fetch, yield* _(Fetch)),
+      Context.add(SecretBox, yield* _(SecretBox)),
+    );
 
     const syncWorker: SyncWorker = {
-      postMessage,
+      postMessage: (input) => {
+        Match.value(input).pipe(
+          Match.tagsExhaustive({
+            sync,
+            syncCompleted: () => syncLock.release,
+          }),
+          Effect.catchAllDefect(makeUnexpectedError),
+          Effect.catchAll(onError),
+          Effect.provide(context),
+          Effect.provideService(SyncWorkerOnMessage, syncWorker.onMessage),
+          Effect.runPromise,
+        );
+      },
       onMessage: Function.constVoid,
     };
 

package/src/index.ts

@@ -1,14 +1,18 @@
-export { jsonArrayFrom, jsonObjectFrom } from "kysely/helpers/sqlite";
 export * from "./Config.js";
 export * from "./Crdt.js";
 export * from "./Crypto.js";
 export * from "./Db.js";
 export * from "./DbWorker.js";
-export * from "./Errors.js";
+export * from "./Diff.js";
+export * from "./ErrorStore.js";
 export * from "./Evolu.js";
 export * from "./Model.js";
+export * from "./Murmurhash.js";
+export * from "./OnCompletes.js";
+export * from "./Owner.js";
 export * from "./Platform.js";
 export * from "./Protobuf.js";
+export * from "./Public.js";
 export * from "./Sqlite.js";
 export * from "./Store.js";
 export * from "./SyncWorker.js";

package/dist/src/Errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Errors.d.ts","sourceRoot":"","sources":["../../src/Errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE3C,MAAM,MAAM,UAAU,GAAG,eAAe,GAAG,cAAc,CAAC;AAE1D;;;;GAIG;AACH,UAAU,iBAAiB;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;CACnC;AAED,eAAO,MAAM,mBAAmB,UACvB,OAAO,KACb,aAAa,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,CAU7C,CAAC"}