@evolu/common 5.4.8 → 6.0.0

package/dist/src/Evolu/Diff.d.ts

@@ -0,0 +1,43 @@
+import { Query, Row } from "./Query.js";
+export interface QueryPatches {
+    readonly query: Query;
+    readonly patches: ReadonlyArray<Patch>;
+}
+export type Patch = ReplaceAllPatch | ReplaceAtPatch;
+export interface ReplaceAllPatch {
+    readonly op: "replaceAll";
+    readonly value: ReadonlyArray<Row>;
+}
+export interface ReplaceAtPatch {
+    readonly op: "replaceAt";
+    readonly index: number;
+    readonly value: Row;
+}
+export declare const applyPatches: (patches: ReadonlyArray<Patch>, current: ReadonlyArray<Row>) => ReadonlyArray<Row>;
+/**
+ * We detect only changes in the whole result and in-place edits. In the future,
+ * we will add more heuristics. We will probably not implement the Myers diff
+ * algorithm because it's faster to rerender all than to compute many detailed
+ * patches. We will only implement logic a developer would implement manually,
+ * if necessary.
+ */
+export declare const makePatches: (previousRows: ReadonlyArray<Row> | undefined, nextRows: ReadonlyArray<Row>) => ReadonlyArray<Patch>;
+/**
+ * A unique identifier prepended to JSON-encoded strings. This allows safe
+ * detection and parsing of only those columns that require JSON.parse.
+ *
+ * The identifier is generated using nanoid to ensure randomness and uniqueness,
+ * preventing malicious actors from inserting fake data that could be
+ * misinterpreted as JSON by the application.
+ *
+ * Note: The same queries created by different browser tabs will have different
+ * identifiers and thus be considered different and cached separately. This is
+ * usually not a big deal, but if needed, the DB cache can be optimized by
+ * passing the kyselyJsonIdentifier into the DB worker during initialization,
+ * allowing queries to be grouped and recognized across tabs or sessions.
+ *
+ * See: https://github.com/kysely-org/kysely/issues/1372#issuecomment-2702773948
+ */
+export declare const kyselyJsonIdentifier: string;
+export declare const parseSqliteJsonArray: <T>(arr: ReadonlyArray<T>) => ReadonlyArray<T>;
+//# sourceMappingURL=Diff.d.ts.map

package/dist/src/Evolu/Diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Diff.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Diff.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;CACxC;AAED,MAAM,MAAM,KAAK,GAAG,eAAe,GAAG,cAAc,CAAC;AAErD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC;CACrB;AAED,eAAO,MAAM,YAAY,GACvB,SAAS,aAAa,CAAC,KAAK,CAAC,EAC7B,SAAS,aAAa,CAAC,GAAG,CAAC,KAC1B,aAAa,CAAC,GAAG,CAUP,CAAC;AAEd;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GACtB,cAAc,aAAa,CAAC,GAAG,CAAC,GAAG,SAAS,EAC5C,UAAU,aAAa,CAAC,GAAG,CAAC,KAC3B,aAAa,CAAC,KAAK,CA6BrB,CAAC;AAUF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,QAAW,CAAC;AAE7C,eAAO,MAAM,oBAAoB,GAAI,CAAC,EACpC,KAAK,aAAa,CAAC,CAAC,CAAC,KACpB,aAAa,CAAC,CAAC,CAMjB,CAAC"}

package/dist/src/Evolu/Diff.js

@@ -0,0 +1,95 @@
+import { nanoid } from "nanoid";
+import { isPlainObject } from "../Object.js";
+import { orderUint8Array } from "../Order.js";
+import { String } from "../Type.js";
+export const applyPatches = (patches, current) => patches.reduce((next, patch) => {
+    switch (patch.op) {
+        case "replaceAll":
+            return parseSqliteJsonArray(patch.value);
+        case "replaceAt": {
+            const parsedRow = parseSqliteJsonArray([patch.value])[0];
+            return next.toSpliced(patch.index, 1, parsedRow);
+        }
+    }
+}, current);
+/**
+ * We detect only changes in the whole result and in-place edits. In the future,
+ * we will add more heuristics. We will probably not implement the Myers diff
+ * algorithm because it's faster to rerender all than to compute many detailed
+ * patches. We will only implement logic a developer would implement manually,
+ * if necessary.
+ */
+export const makePatches = (previousRows, nextRows) => {
+    if (previousRows === undefined)
+        return [{ op: "replaceAll", value: nextRows }];
+    // TODO: Detect prepend and append, it's cheap.
+    if (previousRows.length !== nextRows.length) {
+        return [{ op: "replaceAll", value: nextRows }];
+    }
+    const length = previousRows.length;
+    const replaceAtPatches = [];
+    for (let i = 0; i < length; i++) {
+        const previousRow = previousRows[i];
+        const nextRow = nextRows[i];
+        // We expect the same shape for both rows.
+        for (const key in previousRow)
+            if (!areEqual(previousRow[key], nextRow[key])) {
+                replaceAtPatches.push({ op: "replaceAt", value: nextRow, index: i });
+                break;
+            }
+    }
+    if (length > 0 && replaceAtPatches.length === length) {
+        return [{ op: "replaceAll", value: nextRows }];
+    }
+    return replaceAtPatches;
+};
+// TODO: Replace with eqSqliteValue.
+const areEqual = (a, b) => {
+    if (a instanceof Uint8Array && b instanceof Uint8Array) {
+        return orderUint8Array(a, b) === 0;
+    }
+    return a === b;
+};
+/**
+ * A unique identifier prepended to JSON-encoded strings. This allows safe
+ * detection and parsing of only those columns that require JSON.parse.
+ *
+ * The identifier is generated using nanoid to ensure randomness and uniqueness,
+ * preventing malicious actors from inserting fake data that could be
+ * misinterpreted as JSON by the application.
+ *
+ * Note: The same queries created by different browser tabs will have different
+ * identifiers and thus be considered different and cached separately. This is
+ * usually not a big deal, but if needed, the DB cache can be optimized by
+ * passing the kyselyJsonIdentifier into the DB worker during initialization,
+ * allowing queries to be grouped and recognized across tabs or sessions.
+ *
+ * See: https://github.com/kysely-org/kysely/issues/1372#issuecomment-2702773948
+ */
+export const kyselyJsonIdentifier = nanoid();
+export const parseSqliteJsonArray = (arr) => {
+    const result = new Array(arr.length);
+    for (let i = 0; i < arr.length; ++i) {
+        result[i] = parse(arr[i]);
+    }
+    return result;
+};
+const parse = (obj) => {
+    if (String.is(obj) && obj.startsWith(kyselyJsonIdentifier)) {
+        return JSON.parse(obj.slice(kyselyJsonIdentifier.length));
+    }
+    if (Array.isArray(obj)) {
+        return parseSqliteJsonArray(obj);
+    }
+    if (isPlainObject(obj)) {
+        return parseObject(obj);
+    }
+    return obj;
+};
+const parseObject = (obj) => {
+    const result = Object.create(null);
+    for (const key in obj) {
+        result[key] = parse(obj[key]);
+    }
+    return result;
+};

package/dist/src/Evolu/Evolu.d.ts

@@ -0,0 +1,334 @@
+import { ConsoleDep } from "../Console.js";
+import { SymmetricCryptoDecryptError } from "../Crypto.js";
+import { TransferableError } from "../Error.js";
+import { NanoIdLibDep } from "../NanoId.js";
+import { SqliteError } from "../Sqlite.js";
+import { StoreSubscribe } from "../Store.js";
+import { TimeDep } from "../Time.js";
+import { Mnemonic } from "../Type.js";
+import { Config } from "./Config.js";
+import { CreateDbWorkerDep } from "./Db.js";
+import { AppOwner } from "./Owner.js";
+import { CreateAppStateDep, FlushSyncDep } from "./Platform.js";
+import { ProtocolError, ProtocolUnsupportedVersionError } from "./Protocol.js";
+import { Queries, QueriesToQueryRowsPromises, Query, QueryRows, Row } from "./Query.js";
+import { CreateQuery, EvoluSchema, Mutation } from "./Schema.js";
+import { SyncState } from "./Sync.js";
+import { TimestampError } from "./Timestamp.js";
+export interface Evolu<S extends EvoluSchema = EvoluSchema> {
+    /**
+     * Subscribe to {@link EvoluError} changes.
+     *
+     * ### Example
+     *
+     * ```ts
+     * const unsubscribe = evolu.subscribeError(() => {
+     *   const error = evolu.getError();
+     *   console.log(error);
+     * });
+     * ```
+     */
+    readonly subscribeError: StoreSubscribe;
+    /** Get {@link EvoluError}. */
+    readonly getError: () => EvoluError | null;
+    /**
+     * Create type-safe SQL {@link Query}.
+     *
+     * Evolu uses Kysely - the type-safe SQL query builder for TypeScript. See
+     * https://kysely.dev.
+     *
+     * All this function does is compile the Kysely query and serialize it into a
+     * unique string. Both operations are fast and cheap.
+     *
+     * For mutations, use {@link Evolu.insert} and {@link Evolu.update}.
+     *
+     * ### Example
+     *
+     * ```ts
+     * const allTodos = evolu.createQuery((db) =>
+     *   db.selectFrom("todo").selectAll(),
+     * );
+     *
+     * const todoById = (id: TodoId) =>
+     *   evolu.createQuery((db) =>
+     *     db.selectFrom("todo").selectAll().where("id", "=", id),
+     *   );
+     * ```
+     */
+    readonly createQuery: CreateQuery<S>;
+    /**
+     * Load {@link Query} and return a promise with {@link QueryRows}.
+     *
+     * A returned promise always resolves successfully because there is no reason
+     * why loading should fail. All data are local, and the query is typed. A
+     * serious unexpected Evolu error shall be handled with
+     * {@link Evolu.subscribeError}.
+     *
+     * Loading is batched, and returned promises are cached, so there is no need
+     * for an additional cache. Evolu's internal cache is invalidated on
+     * mutation.
+     *
+     * The returned promise is enriched with special status and value properties
+     * for the upcoming React `use` Hook, but other UI libraries can also leverage
+     * them. Speaking of React, there are two essential React Suspense-related
+     * patterns that every developer should be aware of—passing promises to
+     * children and caching over mutations.
+     *
+     * With promises passed to children, we can load a query as soon as possible,
+     * but we don't have to use the returned promise immediately. That's useful
+     * for prefetching, which is generally not necessary for local-first apps but
+     * can be if a query takes a long time to load.
+     *
+     * Caching over mutation is a pattern that every developer should know. As we
+     * said, Evolu caches promise until a mutation happens. A query loaded after
+     * that will return a new pending promise. That's okay for general usage but
+     * not for UI with React Suspense because a mutation would suspend rerendered
+     * queries on a page, and that's not a good UX.
+     *
+     * We call this pattern "caching over mutation" because it has no globally
+     * accepted name yet. React RFC for React Cache does not exist yet.
+     *
+     * For better UX, a query must be subscribed for updates. This way, instead of
+     * Suspense flashes, the user sees new data immediately because Evolu replaces
+     * cached promises with fresh, already resolved new ones.
+     *
+     * If you are curious why Evolu does not do that for all queries by default,
+     * the answer is simple: performance. Tracking changes is costly and
+     * meaningful only for visible (hence subscribed) queries anyway. To subscribe
+     * to a query, use {@link Evolu.subscribeQuery}.
+     *
+     * ### Example
+     *
+     * ```ts
+     * const allTodos = evolu.createQuery((db) =>
+     *   db.selectFrom("todo").selectAll(),
+     * );
+     * evolu.loadQuery(allTodos).then(({ rows }) => {
+     *   console.log(rows);
+     * });
+     * ```
+     */
+    readonly loadQuery: <R extends Row>(query: Query<R>) => Promise<QueryRows<R>>;
+    /**
+     * Load an array of {@link Query} queries and return an array of
+     * {@link QueryRows} promises. It's like `queries.map(loadQuery)` but with
+     * proper types for returned promises.
+     *
+     * ### Example
+     *
+     * ```ts
+     * evolu.loadQueries([allTodos, todoById(1)]);
+     * ```
+     */
+    readonly loadQueries: <R extends Row, Q extends Queries<R>>(queries: [...Q]) => [...QueriesToQueryRowsPromises<Q>];
+    /**
+     * Subscribe to {@link Query} {@link QueryRows} changes.
+     *
+     * ### Example
+     *
+     * ```ts
+     * const unsubscribe = evolu.subscribeQuery(allTodos)(() => {
+     *   const rows = evolu.getQueryRows(allTodos);
+     * });
+     * ```
+     */
+    readonly subscribeQuery: (query: Query) => StoreSubscribe;
+    /**
+     * Get {@link QueryRows}.
+     *
+     * ### Example
+     *
+     * ```ts
+     * const unsubscribe = evolu.subscribeQuery(allTodos)(() => {
+     *   const rows = evolu.getQueryRows(allTodos);
+     * });
+     * ```
+     */
+    readonly getQueryRows: <R extends Row>(query: Query<R>) => QueryRows<R>;
+    /**
+     * Subscribe to {@link AppOwner} changes.
+     *
+     * ### Example
+     *
+     * ```ts
+     * const unsubscribe = evolu.subscribeAppOwner(() => {
+     *   const owner = evolu.getAppOwner();
+     * });
+     * ```
+     */
+    readonly subscribeAppOwner: StoreSubscribe;
+    /**
+     * Get {@link AppOwner}.
+     *
+     * ### Example
+     *
+     * ```ts
+     * const unsubscribe = evolu.subscribeAppOwner(() => {
+     *   const owner = evolu.getAppOwner();
+     * });
+     * ```
+     */
+    readonly getAppOwner: () => AppOwner | null;
+    /**
+     * Subscribe to {@link SyncState} changes.
+     *
+     * ### Example
+     *
+     * ```ts
+     * const unsubscribe = evolu.subscribeSyncState(() => {
+     *   const syncState = evolu.getSyncState();
+     * });
+     * ```
+     */
+    readonly subscribeSyncState: StoreSubscribe;
+    /**
+     * Get {@link SyncState}.
+     *
+     * ### Example
+     *
+     * ```ts
+     * const unsubscribe = evolu.subscribeSyncState(() => {
+     *   const syncState = evolu.getSyncState();
+     * });
+     * ```
+     */
+    readonly getSyncState: () => SyncState;
+    /**
+     * Inserts a row.
+     *
+     * ### Example
+     *
+     * ```ts
+     * // TODO:
+     * ```
+     */
+    insert: Mutation<S, "insert">;
+    /**
+     * Updates a row.
+     *
+     * ### Example
+     *
+     * ```ts
+     * // TODO:
+     * ```
+     */
+    update: Mutation<S, "update">;
+    /**
+     * Upserts a row.
+     *
+     * ### Example
+     *
+     * ```ts
+     * // TODO:
+     * ```
+     */
+    upsert: Mutation<S, "upsert">;
+    /**
+     * Delete {@link AppOwner} and all their data from the current device. After
+     * the deletion, Evolu will purge the application state. For browsers, this
+     * will reload all tabs using Evolu. For native apps, it will restart the
+     * app.
+     *
+     * Reloading can be turned off via options if you want to provide a different
+     * UX.
+     */
+    readonly resetAppOwner: (options?: {
+        readonly reload?: boolean;
+    }) => Promise<void>;
+    /**
+     * Restore {@link AppOwner} with all their synced data. It uses
+     * {@link Evolu.resetAppOwner}, so be careful.
+     */
+    readonly restoreAppOwner: (mnemonic: Mnemonic, options?: {
+        readonly reload?: boolean;
+    }) => Promise<void>;
+    /**
+     * Reload the app in a platform-specific way. For browsers, this will reload
+     * all tabs using Evolu. For native apps, it will restart the app.
+     */
+    readonly reloadApp: () => void;
+    /** Export SQLite database file as Uint8Array. */
+    readonly exportDatabase: () => Promise<Uint8Array>;
+}
+/** Represent errors that can occur in Evolu. */
+export type EvoluError = TimestampError | ProtocolError | TransferableError | SymmetricCryptoDecryptError | ProtocolUnsupportedVersionError | SqliteError;
+export type EvoluDeps = CreateDbWorkerDep & TimeDep & NanoIdLibDep & Partial<FlushSyncDep> & ConsoleDep & CreateAppStateDep;
+export interface EvoluConfigWithInitialData<S extends EvoluSchema = EvoluSchema> extends Config {
+    /**
+     * Use this option to create initial data (fixtures).
+     *
+     * ### Example
+     *
+     * ```ts
+     * const evolu = createEvolu(evoluReactWebDeps)(Schema, {
+     *   initialData: (evolu) => {
+     *     const todoCategory = evolu.insert("todoCategory", {
+     *       name: "Not Urgent",
+     *     });
+     *
+     *     // This is a developer error, which should be fixed immediately.
+     *     assert(todoCategory.ok, "invalid initial data");
+     *
+     *     evolu.insert("todo", {
+     *       title: "Try React Suspense",
+     *       categoryId: todoCategory.value.id,
+     *     });
+     *   },
+     * });
+     * ```
+     */
+    initialData?: (evolu: EvoluForInitialData<S>) => void;
+}
+export interface EvoluForInitialData<S extends EvoluSchema = EvoluSchema> {
+    insert: Mutation<S, "insert">;
+}
+/**
+ * Creates an {@link Evolu} instance configured with the specified
+ * {@link EvoluSchema} and optional configuration.
+ *
+ * This function returns a configured Evolu instance, providing a typed
+ * interface for querying, mutating, and syncing your application's data. The
+ * returned instance includes:
+ *
+ * - Subscription methods for receiving updates on queries, the owner, errors, and
+ *   sync state.
+ * - Methods for creating, updating, or deleting rows in a type-safe manner.
+ * - Methods for querying data using Evolu's typed SQL queries, leveraging Kysely
+ *   under the hood.
+ * - Built-in support for local-first and offline-first data with automatic sync
+ *   and merging.
+ * - Automatic schema evolution that updates the underlying database with new
+ *   columns or tables.
+ * - Managing owner data with resetAppOwner and restoreAppOwner.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const TodoId = id("Todo");
+ * type TodoId = InferType<typeof TodoId>;
+ *
+ * const TodoCategoryId = id("TodoCategory");
+ * type TodoCategoryId = InferType<typeof TodoCategoryId>;
+ *
+ * const NonEmptyString50 = maxLength(50, NonEmptyString);
+ * type NonEmptyString50 = InferType<typeof NonEmptyString50>;
+ *
+ * const Schema = {
+ *   todo: {
+ *     id: TodoId,
+ *     title: NonEmptyString1000,
+ *     isCompleted: nullOr(SqliteBoolean),
+ *     categoryId: nullOr(TodoCategoryId),
+ *   },
+ *   todoCategory: {
+ *     id: TodoCategoryId,
+ *     name: NonEmptyString50,
+ *   },
+ * };
+ *
+ * const evolu = createEvolu(evoluReactDeps)(Schema);
+ * ```
+ */
+export declare const createEvolu: (deps: EvoluDeps) => <S extends EvoluSchema>(schema: S, partialConfig?: Partial<EvoluConfigWithInitialData<S>>) => Evolu<S>;
+export declare const createNamespaceName: (config: Config) => (name: string) => string;
+//# sourceMappingURL=Evolu.d.ts.map

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

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