@evolu/common 5.4.8 → 6.0.0

package/dist/src/Sqlite.js

@@ -1,68 +1,163 @@
-import * as Console from "effect/Console";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Layer from "effect/Layer";
-import * as Predicate from "effect/Predicate";
-export const Sqlite = Context.GenericTag("Sqlite");
-export class SqliteFactory extends Context.Tag("SqliteFactory")() {
-}
-SqliteFactory.Common = Layer.effect(SqliteFactory, Effect.map(SqliteFactory, (platformSqliteFactory) => ({
-    createSqlite: Effect.logTrace("SqliteFactory createSqlite").pipe(Effect.zipRight(platformSqliteFactory.createSqlite), Effect.map((platformSqlite) => ({
-        ...platformSqlite,
-        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));
+import { createTransferableError } from "./Error.js";
+import { err, ok, tryAsync, trySync } from "./Result.js";
+import { Boolean, Null, Number, String, transform, Uint8Array, union, } from "./Type.js";
+/**
+ * A value that can be stored in Sqlite.
+ *
+ * Note that Evolu can't support Int64 because expo-sqlite (and some others) do
+ * not support it.
+ */
+export const SqliteValue = union(Null, String, Number, Uint8Array);
+/**
+ * Creates a fully featured {@link Sqlite} instance from a {@link SqliteDriver}
+ * implementation.
+ */
+export const createSqlite = (deps) => async (name, options) => tryAsync(async () => {
+    const driver = await deps.createSqliteDriver(name, options);
+    let isDisposed = false;
+    const doRollback = () => trySync(() => {
+        deps.console?.log("[sql] rollback");
+        driver.exec(sql `rollback;`, true);
+    }, createSqliteError);
+    const sqlite = {
+        exec: (query) => trySync(() => {
+            deps.console?.log("[sql]", query);
+            const result = maybeLogSqliteQueryExecutionTime(query, () => driver.exec(query, isSqlMutation(query.sql)));
+            deps.console?.log("[sql]", result);
+            return result;
+        }, (error) => ({
+            type: "SqliteError",
+            error: createTransferableError(error),
+        })),
+        transaction: (callback) => {
+            const transactionResult = trySync(() => {
+                deps.console?.log("[sql] begin");
+                driver.exec(sql `begin;`, true);
+                const result = callback();
+                if (!result.ok)
+                    return result;
+                deps.console?.log("[sql] commit");
+                driver.exec(sql `commit;`, true);
+                return result;
+            }, createSqliteError);
+            // There was an SqliteError during begin, callback, or commit
+            if (!transactionResult.ok) {
+                const rollback = doRollback();
+                if (!rollback.ok) {
+                    deps.console?.log("[sql] rollback failed", rollback.error);
+                    return err({
+                        type: "SqliteError",
+                        error: transactionResult.error.error,
+                        rollbackError: rollback.error.error,
+                    });
+                }
+                return transactionResult;
+            }
+            // Callback returned an error
+            if (!transactionResult.value.ok) {
+                const rollback = doRollback();
+                if (!rollback.ok) {
+                    deps.console?.log("[sql] rollback failed", rollback.error);
+                    return err({
+                        type: "SqliteError",
+                        error: createTransferableError(transactionResult.value.error),
+                        rollbackError: rollback.error.error,
+                    });
+                }
+                return transactionResult.value;
+            }
+            return ok(transactionResult.value.value);
         },
-    }))),
-})));
-export const isJsonObjectOrArray = (value) => value !== null && typeof value === "object" && !Predicate.isUint8Array(value);
-export const valuesToSqliteValues = (values) => values.map((value) => isJsonObjectOrArray(value) ? JSON.stringify(value) : value);
-/** This function mutates for better performance. */
-export const maybeParseJson = (rows) => {
-    parseArray(rows);
-};
-const parseArray = (a) => {
-    for (let i = 0; i < a.length; ++i)
-        a[i] = parse(a[i]);
-    return a;
+        export: () => trySync(() => {
+            return driver.export();
+        }, (error) => ({
+            type: "SqliteError",
+            error: createTransferableError(error),
+        })),
+        [Symbol.dispose]: () => {
+            if (isDisposed)
+                return;
+            isDisposed = true;
+            driver[Symbol.dispose]();
+        },
+    };
+    return sqlite;
+}, createSqliteError);
+const createSqliteError = (error) => ({
+    type: "SqliteError",
+    error: createTransferableError(error),
+});
+const maybeLogSqliteQueryExecutionTime = (query, callback) => {
+    if (!query.options?.logQueryExecutionTime) {
+        return callback();
+    }
+    const start = performance.now();
+    const result = callback();
+    const elapsed = performance.now() - start;
+    // eslint-disable-next-line no-console
+    console.log(`SqliteQueryExecutionTime: ${elapsed.toString()}ms`, query);
+    return result;
 };
-const parse = (o) => {
-    if (Predicate.isString(o))
-        return parseString(o);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    if (Array.isArray(o))
-        return parseArray(o);
-    if (typeof o === "object" && o !== null && !Predicate.isUint8Array(o))
-        return parseObject(o);
-    return o;
+export const createPreparedStatementsCache = (factory, disposeFn) => {
+    let isDisposed = false;
+    const cache = new Map();
+    return {
+        get: (query, alwaysPrepare) => {
+            if (alwaysPrepare !== true && !query.options?.prepare)
+                return null;
+            let statement = cache.get(query.sql);
+            if (!statement) {
+                statement = factory(query.sql);
+                cache.set(query.sql, statement);
+            }
+            return statement;
+        },
+        [Symbol.dispose]: () => {
+            if (isDisposed)
+                return;
+            isDisposed = true;
+            cache.forEach(disposeFn);
+            cache.clear();
+        },
+    };
 };
-const parseString = (s) => {
-    if (maybeJson(s))
-        try {
-            return parse(JSON.parse(s));
-        }
-        catch (err) {
-            // Nothing to do.
+/** TODO: Docs. */
+export const sql = (strings, ...parameters) => {
+    let sql = "";
+    const values = [];
+    for (let i = 0; i < strings.length; i++) {
+        sql += strings[i];
+        if (i < parameters.length) {
+            const param = parameters[i];
+            if (typeof param === "object" && param != null && "type" in param) {
+                sql += param.sql;
+            }
+            else {
+                sql += "?";
+                values.push(param);
+            }
         }
-    return s;
+    }
+    return { sql: sql, parameters: values };
 };
-export const maybeJson = (value) => value.match(/^[[{]/) != null;
-const parseObject = (o) => {
-    for (const key in o)
-        o[key] = parse(o[key]);
-    return o;
+sql.identifier = (identifier) => ({
+    type: "SqlIdentifier",
+    // From Kysely
+    sql: `"${identifier.replace(/"/g, '""')}"`,
+});
+/**
+ * Insert any string.
+ *
+ * Sql.raw sometimes breaks auto-formatting because the parser does not consider
+ * it valid SQL. A workaround is to remove it, format it, and put it back.
+ *
+ * **Warning**: This is not escaped.
+ */
+sql.raw = (raw) => ({ type: "RawSql", sql: raw });
+sql.prepared = (strings, ...parameters) => {
+    const query = sql(strings, ...parameters);
+    return { ...query, options: { prepare: true } };
 };
-/** This is good enough detection because SQL strings in Evolu are predictable. */
 const isSqlMutationRegEx = new RegExp(`\\b(${[
     "alter",
     "create",
@@ -71,14 +166,27 @@ const isSqlMutationRegEx = new RegExp(`\\b(${[
     "insert",
     "replace",
     "update",
-].join("|")})\\b`);
-export const isSqlMutation = (sql) => isSqlMutationRegEx.test(sql);
-export const maybeLogSqliteQueryExecutionTime = (query) => (effect) => {
-    if (!query.options?.logQueryExecutionTime)
-        return effect;
-    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));
+    "begin",
+    "commit",
+    "rollback",
+    "pragma",
+    "vacuum",
+].join("|")})\\b`, "i");
+export const isSqlMutation = (sql) => isSqlMutationRegEx.test(sql.replace(/--.*$/gm, ""));
+export const explainSqliteQueryPlan = (deps) => (query) => {
+    const result = deps.sqlite.exec({
+        ...query,
+        sql: `EXPLAIN QUERY PLAN ${query.sql}`,
+    });
+    if (!result.ok)
+        return result;
+    // eslint-disable-next-line no-console
+    console.log("ExplainQueryPlan", query);
+    // eslint-disable-next-line no-console
+    console.log(drawSqliteQueryPlan(result.value.rows));
+    return ok();
 };
-export const drawSqliteQueryPlan = (rows) => rows
+const drawSqliteQueryPlan = (rows) => rows
     .map((row) => {
     let parentId = row.parent;
     let indent = 0;
@@ -88,8 +196,16 @@ export const drawSqliteQueryPlan = (rows) => rows
             break;
         parentId = parent.parent;
         indent++;
-        // eslint-disable-next-line no-constant-condition
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, no-constant-condition
     } while (true);
     return `${"  ".repeat(indent)}${row.detail}`;
 })
     .join("\n");
+/**
+ * SQLite represents boolean values using `0` (false) and `1` (true) instead of
+ * a dedicated boolean type. This transform Type ensures that values conform to
+ * SQLite's boolean representation.
+ *
+ * See: https://www.sqlite.org/quirks.html#no_separate_boolean_datatype
+ */
+export const SqliteBoolean = transform(Boolean, union(0, 1), (value) => ok(value ? 1 : 0), (value) => value === 1);

package/dist/src/Store.d.ts

@@ -1,10 +1,47 @@
-import * as Effect from "effect/Effect";
-export type Listener = () => void;
-export type Unsubscribe = () => void;
-export interface Store<T> {
-    readonly subscribe: (listener: Listener) => Unsubscribe;
-    readonly getState: () => T;
-    readonly setState: (state: T) => Effect.Effect<void>;
+/**
+ * A mutable reference for managing state with change notifications
+ *
+ * @module
+ */
+import { Eq } from "./Eq.js";
+import { Ref } from "./Ref.js";
+/**
+ * A store for managing state with change notifications. Extends {@link Ref} with
+ * subscriptions. Provides methods to get, set, and modify state, and to notify
+ * listeners when the state changes.
+ */
+export interface Store<T> extends Ref<T> {
+    /**
+     * Registers a listener to be called on state changes and returns a function
+     * to unsubscribe.
+     */
+    readonly subscribe: StoreSubscribe;
+    /** Returns the current state of the store. */
+    readonly get: () => T;
+    /**
+     * Updates the store's state and notifies all subscribed listeners if the new
+     * state differs from the current one.
+     */
+    readonly set: (state: T) => void;
+    /**
+     * Modifies the store's state by applying a callback function to the current
+     * state and notifies listeners if the state changes.
+     */
+    readonly modify: (updater: (current: T) => T) => void;
 }
-export declare const makeStore: <T>(initialState: T) => Effect.Effect<Store<T>>;
+/** Registers a listener for state changes, returning an unsubscribe function. */
+export type StoreSubscribe = (listener: StoreListener) => StoreUnsubscribe;
+/** A callback invoked whenever the store's state updates. */
+export type StoreListener = () => void;
+/** A function to remove a previously added listener. */
+export type StoreUnsubscribe = () => void;
+/**
+ * Creates a store with the given initial state. The store encapsulates its
+ * state, which can be read with `get` and updated with `set` or `modify`. All
+ * changes are broadcast to subscribers.
+ *
+ * By default, state changes are detected using `===` (shallow equality). You
+ * can provide a custom equality function as the second argument.
+ */
+export declare const createStore: <T>(initialState: T, eq?: Eq<T>) => Store<T>;
 //# sourceMappingURL=Store.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Store.d.ts","sourceRoot":"","sources":["../../src/Store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,MAAM,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC;AAElC,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC;AAErC,MAAM,WAAW,KAAK,CAAC,CAAC;IAEtB,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,WAAW,CAAC;IACxD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAG3B,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CACtD;AAED,eAAO,MAAM,SAAS,GAAI,CAAC,gBAAgB,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CA0BjE,CAAC"}
+{"version":3,"file":"Store.d.ts","sourceRoot":"","sources":["../../src/Store.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,EAAE,EAAY,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B;;;;GAIG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,CAAC;IACtC;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IAEnC,8CAA8C;IAC9C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAEtB;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAEjC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;CACvD;AAED,iFAAiF;AACjF,MAAM,MAAM,cAAc,GAAG,CAAC,QAAQ,EAAE,aAAa,KAAK,gBAAgB,CAAC;AAE3E,6DAA6D;AAC7D,MAAM,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC;AAEvC,wDAAwD;AACxD,MAAM,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC;AAE1C;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAC3B,cAAc,CAAC,EACf,KAAI,EAAE,CAAC,CAAC,CAAY,KACnB,KAAK,CAAC,CAAC,CA4BT,CAAC"}

package/dist/src/Store.js

@@ -1,23 +1,39 @@
-import * as Effect from "effect/Effect";
-export const makeStore = (initialState) => Effect.sync(() => {
+/**
+ * A mutable reference for managing state with change notifications
+ *
+ * @module
+ */
+import { eqStrict } from "./Eq.js";
+/**
+ * Creates a store with the given initial state. The store encapsulates its
+ * state, which can be read with `get` and updated with `set` or `modify`. All
+ * changes are broadcast to subscribers.
+ *
+ * By default, state changes are detected using `===` (shallow equality). You
+ * can provide a custom equality function as the second argument.
+ */
+export const createStore = (initialState, eq = eqStrict) => {
     const listeners = new Set();
     let currentState = initialState;
-    const store = {
-        subscribe(listener) {
+    const updateState = (newState) => {
+        if (eq(newState, currentState))
+            return;
+        currentState = newState;
+        listeners.forEach((listener) => {
+            listener();
+        });
+    };
+    return {
+        subscribe: (listener) => {
             listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
+            return () => listeners.delete(listener);
+        },
+        get: () => currentState,
+        set: (state) => {
+            updateState(state);
         },
-        getState() {
-            return currentState;
+        modify: (updater) => {
+            updateState(updater(currentState));
         },
-        setState: (state) => Effect.sync(() => {
-            if (state === currentState)
-                return;
-            currentState = state;
-            listeners.forEach((listener) => listener());
-        }),
     };
-    return store;
-});
+};

package/dist/src/String.d.ts

@@ -0,0 +1,2 @@
+export declare const safelyStringifyUnknownValue: (value: unknown) => string;
+//# sourceMappingURL=String.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"String.d.ts","sourceRoot":"","sources":["../../src/String.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,GAAI,OAAO,OAAO,KAAG,MAS5D,CAAC"}

package/dist/src/String.js

@@ -0,0 +1,14 @@
+export const safelyStringifyUnknownValue = (value) => {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    if (typeof value === "string")
+        return `"${value}"`;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return globalThis.String(value);
+    }
+};

package/dist/src/Time.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ⏳
+ *
+ * @module
+ */
+/** Retrieves the current time in milliseconds, similar to `Date.now()`. */
+export interface Time {
+    readonly now: () => number;
+}
+export interface TimeDep {
+    readonly time: Time;
+}
+/** Creates a {@link Time} using Date.now(). */
+export declare const createTime: () => Time;
+/**
+ * Creates a {@link Time} that returns a monotonically increasing number based on
+ * a queueMicrotask.
+ */
+export declare const createTestTime: () => Time;
+//# sourceMappingURL=Time.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Time.d.ts","sourceRoot":"","sources":["../../src/Time.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,2EAA2E;AAC3E,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB;AAED,+CAA+C;AAC/C,eAAO,MAAM,UAAU,QAAO,IAE5B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,cAAc,QAAO,IAWjC,CAAC"}

package/dist/src/Time.js

@@ -0,0 +1,25 @@
+/**
+ * ⏳
+ *
+ * @module
+ */
+/** Creates a {@link Time} using Date.now(). */
+export const createTime = () => ({
+    now: () => Date.now(),
+});
+/**
+ * Creates a {@link Time} that returns a monotonically increasing number based on
+ * a queueMicrotask.
+ */
+export const createTestTime = () => {
+    let now = 0;
+    return {
+        now: () => {
+            const current = now;
+            queueMicrotask(() => {
+                now++;
+            });
+            return current;
+        },
+    };
+};