@evolu/common 4.1.1 → 5.0.1

package/dist/src/DbWorker.js

@@ -1,335 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import { pipe } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Match from "effect/Match";
-import * as Option from "effect/Option";
-import * as ReadonlyArray from "effect/ReadonlyArray";
-import { Config, ConfigLive } from "./Config.js";
-import { Time, TimeLive, diffMerkleTrees, insertIntoMerkleTree, makeSyncTimestamp, merkleTreeToString, receiveTimestamp, sendTimestamp, timestampToString, unsafeTimestampFromString, } from "./Crdt.js";
-import { Bip39, NanoIdGenerator } from "./Crypto.js";
-import { RowsStore, RowsStoreLive, deserializeQuery, dropAllTables, ensureSchema, lazyInit, someDefectToNoSuchTableOrColumnError, transaction, } from "./Db.js";
-import { makePatches } from "./Diff.js";
-import { makeUnexpectedError } from "./ErrorStore.js";
-import { cast } from "./Model.js";
-import { Owner } from "./Owner.js";
-import { DbWorkerLock } from "./Platform.js";
-import * as Sql from "./Sql.js";
-import { Sqlite, drawSqliteQueryPlan as drawExplainQueryPlan, } from "./Sqlite.js";
-import { NewMessageEquivalence, SyncWorker, SyncWorkerPostMessage, } from "./SyncWorker.js";
-export const DbWorker = Context.GenericTag("@services/DbWorker");
-const DbWorkerOnMessage = Context.GenericTag("@services/DbWorkerOnMessage");
-const init = Effect.gen(function* (_) {
-    const sqlite = yield* _(Sqlite);
-    return yield* _(sqlite.exec(Sql.selectOwner), Effect.map(({ rows: [row] }) => ({
-        id: row.id,
-        mnemonic: row.mnemonic,
-        encryptionKey: row.encryptionKey,
-    })), someDefectToNoSuchTableOrColumnError, Effect.catchTag("NoSuchTableOrColumnError", () => lazyInit()));
-});
-const query = ({ queries, onCompleteIds = [], }) => Effect.gen(function* (_) {
-    const sqlite = yield* _(Sqlite);
-    const rowsStore = yield* _(RowsStore);
-    const dbWorkerOnMessage = yield* _(DbWorkerOnMessage);
-    const queriesRows = yield* _(ReadonlyArray.dedupe(queries), Effect.forEach((query) => {
-        const sqliteQuery = deserializeQuery(query);
-        return sqlite.exec(sqliteQuery).pipe(Effect.map((result) => [query, result.rows]), Effect.tap(() => {
-            if (!sqliteQuery.options?.logExplainQueryPlan)
-                return;
-            return sqlite
-                .exec({
-                ...sqliteQuery,
-                sql: `EXPLAIN QUERY PLAN ${sqliteQuery.sql}`,
-            })
-                .pipe(Effect.tap(() => Effect.log("ExplainQueryPlan")), Effect.tap(({ rows }) => {
-                // Not using Effect.log because of formating
-                // eslint-disable-next-line no-console
-                console.log(drawExplainQueryPlan(rows));
-            }));
-        }));
-    }));
-    const previous = rowsStore.getState();
-    yield* _(rowsStore.setState(new Map([...previous, ...queriesRows])));
-    const queriesPatches = queriesRows.map(([query, rows]) => ({
-        query,
-        patches: makePatches(previous.get(query), rows),
-    }));
-    dbWorkerOnMessage({ _tag: "onQuery", queriesPatches, onCompleteIds });
-});
-const readTimestampAndMerkleTree = Sqlite.pipe(Effect.flatMap((sqlite) => sqlite.exec(Sql.selectOwnerTimestampAndMerkleTree)), Effect.map(({ rows: [{ timestamp, merkleTree }] }) => ({
-    timestamp: unsafeTimestampFromString(timestamp),
-    merkleTree: merkleTree,
-})));
-export const mutationsToNewMessages = (mutations) => pipe(mutations, 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.
-value === undefined || (isInsert && value == null)
-    ? Option.none()
-    : Option.some([key, value])), 
-// Cast values.
-ReadonlyArray.map(([key, value]) => [
-    key,
-    typeof value === "boolean"
-        ? cast(value)
-        : value instanceof Date
-            ? cast(value)
-            : value,
-]), ReadonlyArray.map(([key, value]) => ({
-    table,
-    row: id,
-    column: key,
-    value,
-})))), (a) => a.flat(), ReadonlyArray.dedupeWith(NewMessageEquivalence));
-const ensureSchemaByNewMessages = (messages) => Effect.gen(function* (_) {
-    const tablesMap = new Map();
-    messages.forEach((message) => {
-        const table = tablesMap.get(message.table);
-        if (table == null) {
-            tablesMap.set(message.table, {
-                name: message.table,
-                columns: [message.column, "createdAt", "updatedAt"],
-            });
-            return;
-        }
-        if (table.columns.includes(message.column))
-            return;
-        tablesMap.set(message.table, {
-            name: message.table,
-            columns: table.columns.concat(message.column),
-        });
-    });
-    const tables = Array.from(tablesMap.values());
-    yield* _(ensureSchema({ tables, indexes: [] }));
-});
-export const upsertValueIntoTableRowColumn = (message, messages, millis) => Effect.gen(function* (_) {
-    const sqlite = yield* _(Sqlite);
-    const createdAtOrUpdatedAt = cast(new Date(millis));
-    const insert = sqlite.exec({
-        sql: `
-insert into
-  "${message.table}" ("id", "${message.column}", "createdAt", "updatedAt")
-values
-  (?, ?, ?, ?)
-on conflict do update set
-  "${message.column}" = ?,
-  "updatedAt" = ?
-`.trim(),
-        parameters: [
-            message.row,
-            message.value,
-            createdAtOrUpdatedAt,
-            createdAtOrUpdatedAt,
-            message.value,
-            createdAtOrUpdatedAt,
-        ],
-    });
-    yield* _(insert, someDefectToNoSuchTableOrColumnError, Effect.catchTag("NoSuchTableOrColumnError", () => 
-    // If one message fails, we ensure schema for all messages.
-    ensureSchemaByNewMessages(messages).pipe(Effect.zipRight(insert))));
-});
-const applyMessages = ({ merkleTree, messages, }) => Effect.gen(function* (_) {
-    const sqlite = yield* _(Sqlite);
-    for (const message of messages) {
-        const timestamp = yield* _(sqlite.exec({
-            ...Sql.selectLastTimestampForTableRowColumn,
-            parameters: [message.table, message.row, message.column, 1],
-        }), Effect.map((result) => result.rows), Effect.flatMap(ReadonlyArray.head), Effect.map((row) => row.timestamp), Effect.catchTag("NoSuchElementException", () => Effect.succeed(null)));
-        if (timestamp == null || timestamp < message.timestamp) {
-            const { millis } = unsafeTimestampFromString(message.timestamp);
-            yield* _(upsertValueIntoTableRowColumn(message, messages, millis));
-        }
-        if (timestamp == null || timestamp !== message.timestamp) {
-            const { changes } = yield* _(sqlite.exec({
-                ...Sql.insertIntoMessagesIfNew,
-                parameters: [
-                    message.timestamp,
-                    message.table,
-                    message.row,
-                    message.column,
-                    message.value,
-                ],
-            }));
-            if (changes > 0) {
-                const timestamp = unsafeTimestampFromString(message.timestamp);
-                merkleTree = insertIntoMerkleTree(timestamp)(merkleTree);
-            }
-        }
-    }
-    return merkleTree;
-});
-const writeTimestampAndMerkleTree = ({ timestamp, merkleTree, }) => Effect.flatMap(Sqlite, (sqlite) => sqlite.exec({
-    ...Sql.updateOwnerTimestampAndMerkleTree,
-    parameters: [
-        merkleTreeToString(merkleTree),
-        timestampToString(timestamp),
-    ],
-}));
-const mutate = ({ mutations, queries, }) => Effect.gen(function* (_) {
-    const [toSync, localOnly] = ReadonlyArray.partition(mutations, (item) => item.table.startsWith("_"));
-    const [toUpsert, toDelete] = ReadonlyArray.partition(localOnly, (item) => mutationsToNewMessages([item]).some((message) => message.column === "isDeleted" && message.value === 1)).map(mutationsToNewMessages);
-    const time = yield* _(Time);
-    for (const messageToUpsert of toUpsert) {
-        const now = yield* _(time.now);
-        yield* _(upsertValueIntoTableRowColumn(messageToUpsert, toUpsert, now));
-    }
-    const { exec } = yield* _(Sqlite);
-    yield* _(Effect.forEach(toDelete, ({ table, row }) => exec({
-        sql: `delete from "${table}" where "id" = ?;`,
-        parameters: [row],
-    })));
-    if (toSync.length > 0) {
-        let { timestamp, merkleTree } = yield* _(readTimestampAndMerkleTree);
-        const messages = yield* _(mutationsToNewMessages(toSync), Effect.forEach((message) => Effect.map(sendTimestamp(timestamp), (nextTimestamp) => {
-            timestamp = nextTimestamp;
-            return { ...message, timestamp: timestampToString(timestamp) };
-        })));
-        merkleTree = yield* _(applyMessages({ merkleTree, messages }));
-        yield* _(writeTimestampAndMerkleTree({ timestamp, merkleTree }));
-        (yield* _(SyncWorkerPostMessage))({
-            _tag: "sync",
-            syncUrl: (yield* _(Config)).syncUrl,
-            messages,
-            timestamp,
-            merkleTree,
-            owner: yield* _(Owner),
-            syncLoopCount: 0,
-        });
-    }
-    const onCompleteIds = ReadonlyArray.filterMap(mutations, (item) => Option.fromNullable(item.onCompleteId));
-    if (queries.length > 0 || onCompleteIds.length > 0)
-        yield* _(query({ queries, onCompleteIds }));
-});
-const handleSyncResponse = ({ messages, ...response }) => Effect.gen(function* (_) {
-    let { timestamp, merkleTree } = yield* _(readTimestampAndMerkleTree);
-    const dbWorkerOnMessage = yield* _(DbWorkerOnMessage);
-    if (messages.length > 0) {
-        for (const message of messages)
-            timestamp = yield* _(unsafeTimestampFromString(message.timestamp), (remote) => receiveTimestamp({ local: timestamp, remote }));
-        merkleTree = yield* _(applyMessages({ merkleTree, messages }));
-        yield* _(writeTimestampAndMerkleTree({ timestamp, merkleTree }));
-        dbWorkerOnMessage({ _tag: "onReceive" });
-    }
-    const diff = diffMerkleTrees(response.merkleTree, merkleTree);
-    const syncWorkerPostMessage = yield* _(SyncWorkerPostMessage);
-    if (Option.isNone(diff)) {
-        syncWorkerPostMessage({ _tag: "syncCompleted" });
-        dbWorkerOnMessage({
-            _tag: "onSyncState",
-            state: {
-                _tag: "SyncStateIsSynced",
-                time: yield* _(Time.pipe(Effect.flatMap((time) => time.now))),
-            },
-        });
-        return;
-    }
-    const sqlite = yield* _(Sqlite);
-    const config = yield* _(Config);
-    const owner = yield* _(Owner);
-    const messagesToSync = yield* _(sqlite.exec({
-        ...Sql.selectMessagesToSync,
-        parameters: [timestampToString(makeSyncTimestamp(diff.value))],
-    }), Effect.map(({ rows }) => rows));
-    if (response.syncLoopCount > 100) {
-        // TODO: dbWorkerOnMessage({ _tag: "onError" });
-        // eslint-disable-next-line no-console
-        console.error("Evolu: syncLoopCount > 100");
-        return;
-    }
-    syncWorkerPostMessage({
-        _tag: "sync",
-        syncUrl: config.syncUrl,
-        messages: messagesToSync,
-        timestamp,
-        merkleTree,
-        owner,
-        syncLoopCount: response.syncLoopCount + 1,
-    });
-});
-const sync = ({ queries, }) => Effect.gen(function* (_) {
-    if (queries.length > 0)
-        yield* _(query({ queries }));
-    const syncWorkerPostMessage = yield* _(SyncWorkerPostMessage);
-    syncWorkerPostMessage({
-        _tag: "sync",
-        ...(yield* _(readTimestampAndMerkleTree)),
-        syncUrl: (yield* _(Config)).syncUrl,
-        owner: yield* _(Owner),
-        messages: [],
-        syncLoopCount: 0,
-    });
-});
-const reset = (input) => Effect.gen(function* (_) {
-    yield* _(dropAllTables);
-    if (input.mnemonic)
-        yield* _(lazyInit(input.mnemonic));
-    const onMessage = yield* _(DbWorkerOnMessage);
-    onMessage({ _tag: "onResetOrRestore" });
-});
-export const DbWorkerCommonLive = Layer.effect(DbWorker, Effect.gen(function* (_) {
-    const syncWorker = yield* _(SyncWorker);
-    const onError = (error) => Effect.sync(() => {
-        dbWorker.onMessage({ _tag: "onError", error });
-    });
-    syncWorker.onMessage = (output) => {
-        switch (output._tag) {
-            case "UnexpectedError":
-                onError(output).pipe(Effect.runSync);
-                break;
-            case "SyncWorkerOutputSyncResponse":
-                dbWorker.postMessage(output);
-                break;
-            default:
-                dbWorker.onMessage({ _tag: "onSyncState", state: output });
-        }
-    };
-    const runContext = Context.empty().pipe(Context.add(Sqlite, yield* _(Sqlite)), Context.add(Bip39, yield* _(Bip39)), Context.add(NanoIdGenerator, yield* _(NanoIdGenerator)), Context.add(DbWorkerOnMessage, (output) => {
-        dbWorker.onMessage(output);
-    }));
-    const run = (effect) => effect.pipe(Effect.catchAllDefect(makeUnexpectedError), transaction, Effect.catchAll(onError), Effect.provide(runContext), Effect.runPromise);
-    /** If init fails, we have to allow reset at least. */
-    const handleInputForInitFail = (input) => {
-        if (input._tag !== "reset")
-            return Promise.resolve(undefined);
-        return reset(input).pipe(run);
-    };
-    const makeHandleInputForInitSuccess = (config, owner) => {
-        let skipAllBecauseOfReset = false;
-        const layer = Layer.mergeAll(ConfigLive(config), Layer.succeed(Owner, owner), Layer.succeed(SyncWorkerPostMessage, syncWorker.postMessage), RowsStoreLive, TimeLive).pipe(Layer.memoize, Effect.scoped, Effect.runSync);
-        return (input) => {
-            if (skipAllBecauseOfReset)
-                return Promise.resolve(undefined);
-            return Match.value(input).pipe(Match.tagsExhaustive({
-                init: () => makeUnexpectedError(new Error("init must be called once")),
-                query,
-                mutate,
-                sync,
-                reset: (input) => {
-                    skipAllBecauseOfReset = true;
-                    return reset(input);
-                },
-                ensureSchema,
-                SyncWorkerOutputSyncResponse: handleSyncResponse,
-            }), Effect.provide(layer), run);
-        };
-    };
-    let handleInput = (input) => {
-        if (input._tag !== "init")
-            return run(makeUnexpectedError(new Error("init must be called first")));
-        handleInput = handleInputForInitFail;
-        return init.pipe(Effect.map((owner) => {
-            dbWorker.onMessage({ _tag: "onOwner", owner });
-            handleInput = makeHandleInputForInitSuccess(input.config, owner);
-        }), run);
-    };
-    const dbWorkerLock = yield* _(DbWorkerLock);
-    const dbWorker = {
-        postMessage: (input) => {
-            dbWorkerLock(() => handleInput(input));
-        },
-        onMessage: Function.constVoid,
-    };
-    return dbWorker;
-}));

package/dist/src/ErrorStore.d.ts

@@ -1,29 +0,0 @@
-import * as Effect from "effect/Effect";
-import { TimestampError } from "./Crdt.js";
-export declare const makeErrorStore: Effect.Effect<import("./Store.js").Store<EvoluError | null>, never, never>;
-/** The EvoluError type is used to represent errors that can occur in Evolu. */
-export type EvoluError = UnexpectedError | TimestampError;
-/**
- * The UnexpectedError interface is designed to represent errors that can occur
- * unexpectedly anywhere, even in third-party libraries, because Evolu uses
- * Effect to track all errors.
- */
-export interface UnexpectedError {
-    readonly _tag: "UnexpectedError";
-    readonly error: TransferableError;
-}
-export declare const makeUnexpectedError: (error: unknown) => Effect.Effect<never, UnexpectedError>;
-/**
- * We can't use the whole error because of WebWorker postMessage DataCloneError
- * in Safari and Firefox. TODO:
- * https://discord.com/channels/795981131316985866/795983589644304396/1096736473396564079
- */
-interface TransferableError {
-    readonly message: string;
-    readonly stack: string | undefined;
-}
-export interface EvoluTypeError<E extends string> {
-    readonly __evoluTypeError__: E;
-}
-export {};
-//# sourceMappingURL=ErrorStore.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ErrorStore.d.ts","sourceRoot":"","sources":["../../src/ErrorStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAG3C,eAAO,MAAM,cAAc,4EAAqC,CAAC;AAEjE,+EAA+E;AAC/E,MAAM,MAAM,UAAU,GAAG,eAAe,GAAG,cAAc,CAAC;AAE1D;;;;GAIG;AACH,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,CAUtC,CAAC;AAEF;;;;GAIG;AACH,UAAU,iBAAiB;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,MAAM;IAC9C,QAAQ,CAAC,kBAAkB,EAAE,CAAC,CAAC;CAChC"}

package/dist/src/ErrorStore.js

@@ -1,13 +0,0 @@
-import * as Effect from "effect/Effect";
-import { makeStore } from "./Store.js";
-export const makeErrorStore = makeStore(null);
-export const makeUnexpectedError = (error) => {
-    const isError = error instanceof Error;
-    return Effect.fail({
-        _tag: "UnexpectedError",
-        error: {
-            message: isError ? error.message : String(error),
-            stack: isError ? error.stack : undefined,
-        },
-    });
-};

package/dist/src/OnCompletes.d.ts

@@ -1,14 +0,0 @@
-import * as Brand from "effect/Brand";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { NanoId, NanoIdGenerator } from "./Crypto.js";
-export interface OnCompletes {
-    readonly add: (onComplete: OnComplete) => Effect.Effect<OnCompleteId>;
-    readonly complete: (onCompleteIds: readonly OnCompleteId[]) => Effect.Effect<void>;
-}
-export type OnComplete = () => void;
-export type OnCompleteId = NanoId & Brand.Brand<"OnCompleteId">;
-export declare const OnCompletes: Context.Tag<OnCompletes, OnCompletes>;
-export declare const OnCompletesLive: Layer.Layer<OnCompletes, never, NanoIdGenerator>;
-//# sourceMappingURL=OnCompletes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"OnCompletes.d.ts","sourceRoot":"","sources":["../../src/OnCompletes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEtD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IAEtE,QAAQ,CAAC,QAAQ,EAAE,CACjB,aAAa,EAAE,SAAS,YAAY,EAAE,KACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC;AAEpC,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;AAEhE,eAAO,MAAM,WAAW,uCAEvB,CAAC;AAEF,eAAO,MAAM,eAAe,kDA0B3B,CAAC"}

package/dist/src/OnCompletes.js

@@ -1,25 +0,0 @@
-import * as Context from "effect/Context";
-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 { NanoIdGenerator } from "./Crypto.js";
-export const OnCompletes = Context.GenericTag("@services/OnCompletes");
-export const OnCompletesLive = Layer.effect(OnCompletes, Effect.gen(function* (_) {
-    const { nanoid } = yield* _(NanoIdGenerator);
-    const map = new Map();
-    return OnCompletes.of({
-        add: (onComplete) => nanoid.pipe(Effect.map((nanoid) => {
-            const id = nanoid;
-            map.set(id, onComplete);
-            return id;
-        })),
-        complete: (onCompleteIds) => Effect.sync(() => {
-            ReadonlyArray.filterMap(onCompleteIds, (id) => {
-                const onComplete = map.get(id);
-                map.delete(id);
-                return Option.fromNullable(onComplete);
-            }).forEach((onComplete) => onComplete());
-        }),
-    });
-}));

package/dist/src/SyncWorker.d.ts

@@ -1,80 +0,0 @@
-import * as Context from "effect/Context";
-import * as Equivalence from "effect/Equivalence";
-import * as Layer from "effect/Layer";
-import { MerkleTree, Millis, Timestamp, TimestampString } from "./Crdt.js";
-import { SecretBox } from "./Crypto.js";
-import { UnexpectedError } from "./ErrorStore.js";
-import { Id } from "./Model.js";
-import { Owner } from "./Owner.js";
-import { Fetch, SyncLock } from "./Platform.js";
-import { Value } from "./Sqlite.js";
-import { Messaging } from "./Types.js";
-export interface SyncWorker extends Messaging<SyncWorkerInput, SyncWorkerOutput> {
-}
-export declare const SyncWorker: Context.Tag<SyncWorker, SyncWorker>;
-export type SyncWorkerPostMessage = SyncWorker["postMessage"];
-export declare const SyncWorkerPostMessage: Context.Tag<(input: SyncWorkerInput) => void, (input: SyncWorkerInput) => void>;
-export type SyncWorkerInput = SyncWorkerInputSync | SyncWorkerInputSyncCompleted;
-interface SyncWorkerInputSync {
-    readonly _tag: "sync";
-    readonly syncUrl: string;
-    readonly messages: ReadonlyArray<Message>;
-    readonly merkleTree: MerkleTree;
-    readonly timestamp: Timestamp;
-    readonly owner: Owner;
-    readonly syncLoopCount: number;
-}
-export interface NewMessage {
-    readonly table: string;
-    readonly row: Id;
-    readonly column: string;
-    readonly value: Value;
-}
-export declare const NewMessageEquivalence: Equivalence.Equivalence<NewMessage>;
-export interface Message extends NewMessage {
-    readonly timestamp: TimestampString;
-}
-interface SyncWorkerInputSyncCompleted {
-    readonly _tag: "syncCompleted";
-}
-export type SyncWorkerOutput = UnexpectedError | SyncWorkerOutputSyncResponse | SyncStateIsNotSyncedError | SyncStateIsSyncing;
-export type SyncWorkerOutputSyncResponse = {
-    readonly _tag: "SyncWorkerOutputSyncResponse";
-    readonly messages: ReadonlyArray<Message>;
-    readonly merkleTree: MerkleTree;
-    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 | SyncStateIsSynced | SyncStateIsNotSyncedError;
-export interface SyncStateInitial {
-    readonly _tag: "SyncStateInitial";
-}
-export interface SyncStateIsSyncing {
-    readonly _tag: "SyncStateIsSyncing";
-}
-export interface SyncStateIsSynced {
-    readonly _tag: "SyncStateIsSynced";
-    readonly time: Millis;
-}
-export interface SyncStateIsNotSyncedError {
-    readonly _tag: "SyncStateIsNotSyncedError";
-    readonly error: SyncStateNetworkError | SyncStateServerError | SyncStatePaymentRequiredError;
-}
-export interface SyncStateNetworkError {
-    readonly _tag: "NetworkError";
-}
-export interface SyncStateServerError {
-    readonly _tag: "ServerError";
-    readonly status: number;
-}
-export interface SyncStatePaymentRequiredError {
-    readonly _tag: "PaymentRequiredError";
-}
-export declare const SyncWorkerCommonLive: Layer.Layer<SyncWorker, never, SecretBox | SyncLock | Fetch>;
-export {};
-//# sourceMappingURL=SyncWorker.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"SyncWorker.d.ts","sourceRoot":"","sources":["../../src/SyncWorker.ts"],"names":[],"mappings":"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"}

package/dist/src/SyncWorker.js

@@ -1,150 +0,0 @@
-import * as S from "@effect/schema/Schema";
-import { concatBytes } from "@noble/ciphers/utils";
-import { BinaryReader, BinaryWriter } from "@protobuf-ts/runtime";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import { absurd, identity } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Match from "effect/Match";
-import * as Option from "effect/Option";
-import * as Predicate from "effect/Predicate";
-import * as ReadonlyArray from "effect/ReadonlyArray";
-import { merkleTreeToString, unsafeMerkleTreeFromString, } from "./Crdt.js";
-import { SecretBox } from "./Crypto.js";
-import { makeUnexpectedError } from "./ErrorStore.js";
-import { Fetch, SyncLock } from "./Platform.js";
-import { MessageContent, SyncRequest, SyncResponse, } from "./Protobuf.js";
-export const SyncWorker = Context.GenericTag("@services/SyncWorker");
-export const SyncWorkerPostMessage = Context.GenericTag("@services/SyncWorkerPostMessage");
-export const NewMessageEquivalence = (a, b) => a.table === b.table &&
-    a.row === b.row &&
-    a.column === b.column &&
-    JSON.stringify(a.value) === JSON.stringify(b.value);
-const SyncWorkerOnMessage = Context.GenericTag("@services/SyncWorkerOnMessage");
-const version1 = new Uint8Array([0, 1]);
-const valueToProtobuf = (value) => {
-    switch (typeof value) {
-        case "string":
-            return { oneofKind: "stringValue", stringValue: value };
-        case "number":
-            return {
-                oneofKind: "numberValue",
-                numberValue: S.encodeSync(S.NumberFromString)(value),
-            };
-    }
-    if (value == null)
-        return { oneofKind: undefined };
-    if (Predicate.isUint8Array(value))
-        return { oneofKind: "bytesValue", bytesValue: value };
-    return { oneofKind: "jsonValue", jsonValue: JSON.stringify(value) };
-};
-const valueFromProtobuf = (value) => {
-    switch (value.oneofKind) {
-        case "numberValue":
-            return S.decodeSync(S.NumberFromString)(value.numberValue);
-        case "stringValue":
-            return value.stringValue;
-        case "bytesValue":
-            return value.bytesValue;
-        case "jsonValue":
-            return JSON.parse(value.jsonValue);
-        case undefined:
-            return null;
-        default:
-            return absurd(value);
-    }
-};
-const newMessageToBinary = ({ value, ...rest }) => concatBytes(version1, MessageContent.toBinary({ value: valueToProtobuf(value), ...rest }, binaryWriteOptions));
-const startsWithArray = (array, prefix) => {
-    if (prefix.length > array.length)
-        return false;
-    for (let i = 0; i < prefix.length; i++) {
-        if (array[i] !== prefix[i])
-            return false;
-    }
-    return true;
-};
-const newMessageFromBinary = (binary) => {
-    if (!startsWithArray(binary, version1))
-        return Option.none();
-    const { value, ...content } = MessageContent.fromBinary(binary.slice(version1.length), binaryReadOptions);
-    return Option.some({ value: valueFromProtobuf(value), ...content });
-};
-// The 'protobuf-ts' uses TextEncoder, but polyfill fast-text-encoding
-// doesn't support the fatal option.
-// https://github.com/timostamm/protobuf-ts/issues/184#issuecomment-1658443836
-const binaryWriteOptions = {
-    writerFactory: () => new BinaryWriter({
-        encode: (input) => new TextEncoder().encode(input),
-    }),
-};
-const binaryReadOptions = {
-    readerFactory: (bytes) => new BinaryReader(bytes, {
-        decode: (input) => new TextDecoder().decode(input),
-    }),
-};
-const sync = (input) => Effect.gen(function* (_) {
-    const syncLock = yield* _(SyncLock);
-    const syncWorkerOnMessage = yield* _(SyncWorkerOnMessage);
-    const fetch = yield* _(Fetch);
-    const secretBox = yield* _(SecretBox);
-    if (input.syncLoopCount === 0) {
-        if (!(yield* _(syncLock.acquire)))
-            return;
-        syncWorkerOnMessage({ _tag: "SyncStateIsSyncing" });
-    }
-    yield* _(Effect.forEach(input.messages, ({ timestamp, ...newMessage }) => secretBox
-        .seal(input.owner.encryptionKey, newMessageToBinary(newMessage))
-        .pipe(Effect.map((content) => ({ timestamp, content })))), Effect.map((messages) => SyncRequest.toBinary({
-        messages,
-        userId: input.owner.id,
-        nodeId: input.timestamp.node,
-        merkleTree: merkleTreeToString(input.merkleTree),
-    }, binaryWriteOptions)), Effect.flatMap((body) => fetch(input.syncUrl, body)), Effect.catchTag("FetchError", () => Effect.fail({
-        _tag: "SyncStateIsNotSyncedError",
-        error: { _tag: "NetworkError" },
-    })), Effect.flatMap((response) => {
-        switch (response.status) {
-            case 402:
-                return Effect.fail({
-                    _tag: "SyncStateIsNotSyncedError",
-                    error: { _tag: "PaymentRequiredError" },
-                });
-            case 200:
-                return Effect.promise(() => response
-                    .arrayBuffer()
-                    .then((buffer) => new Uint8Array(buffer))
-                    .then((array) => SyncResponse.fromBinary(array, binaryReadOptions)));
-            default:
-                return Effect.fail({
-                    _tag: "SyncStateIsNotSyncedError",
-                    error: { _tag: "ServerError", status: response.status },
-                });
-        }
-    }), Effect.flatMap((syncResponse) => Effect.forEach(syncResponse.messages, ({ timestamp, content }) => secretBox
-        .open(input.owner.encryptionKey, content)
-        .pipe(Effect.map(newMessageFromBinary), Effect.map(Option.map((newMessage) => ({ timestamp, ...newMessage }))))).pipe(Effect.map((messages) => ({
-        _tag: "SyncWorkerOutputSyncResponse",
-        messages: ReadonlyArray.filterMap(messages, identity),
-        merkleTree: unsafeMerkleTreeFromString(syncResponse.merkleTree),
-        syncLoopCount: input.syncLoopCount,
-    })))), Effect.tapError(() => syncLock.release), Effect.merge, Effect.map(syncWorkerOnMessage));
-});
-export const SyncWorkerCommonLive = Layer.effect(SyncWorker, Effect.gen(function* (_) {
-    const syncLock = yield* _(SyncLock);
-    const onError = (error) => Effect.sync(() => {
-        syncWorker.onMessage(error);
-    });
-    const context = Context.empty().pipe(Context.add(SyncLock, syncLock), Context.add(Fetch, yield* _(Fetch)), Context.add(SecretBox, yield* _(SecretBox)));
-    const syncWorker = {
-        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,
-    };
-    return syncWorker;
-}));