@evolu/common 7.2.3 → 7.3.0

package/src/local-first/Sync.ts

@@ -16,7 +16,7 @@ import {
 import { eqArrayNumber } from "../Eq.js";
 import { createTransferableError, TransferableError } from "../Error.js";
 import { constFalse, constTrue } from "../Function.js";
-import { createRecord, objectToEntries } from "../Object.js";
+import { createRecord, getProperty, objectToEntries } from "../Object.js";
 import { RandomDep } from "../Random.js";
 import { createResources } from "../Resources.js";
 import { err, ok, Result } from "../Result.js";
@@ -34,17 +34,19 @@ import { TimeDep } from "../Time.js";
 import {
   Boolean,
   DateIso,
+  Id,
   IdBytes,
   idBytesToId,
   idToIdBytes,
   PositiveInt,
 } from "../Type.js";
 import { CreateWebSocketDep, WebSocket } from "../WebSocket.js";
-import type { AppOwnerDep, PostMessageDep } from "./Db.js";
 import {
   AppOwner,
+  AppOwnerDep,
   Owner,
   OwnerId,
+  OwnerIdBytes,
   ownerIdBytesToOwnerId,
   ownerIdToOwnerIdBytes,
   OwnerTransport,
@@ -62,7 +64,7 @@ import {
   ProtocolTimestampMismatchError,
   SubscriptionFlags,
 } from "./Protocol.js";
-import { MutationChange } from "./Schema.js";
+import { DbSchemaDep, MutationChange, systemColumns } from "./Schema.js";
 import {
   BaseSqliteStorage,
   CrdtMessage,
@@ -80,6 +82,7 @@ import {
   receiveTimestamp,
   sendTimestamp,
   Timestamp,
+  TimestampBytes,
   timestampBytesToTimestamp,
   TimestampConfigDep,
   TimestampCounterOverflowError,
@@ -157,7 +160,8 @@ export const createSync =
     deps: ClockDep &
       ConsoleDep &
       CreateWebSocketDep &
-      PostMessageDep &
+      DbSchemaDep &
+      // PostMessageDep &
       RandomBytesDep &
       RandomDep &
       SqliteDep &
@@ -324,7 +328,6 @@ export const createSync =
           resources.addConsumer(owner, transports);
         } else {
           const result = resources.removeConsumer(owner, transports);
-
           if (!result.ok) {
             deps.console.warn("[sync]", "Failed to remove consumer", {
               transports,
@@ -445,6 +448,7 @@ export interface ClientStorageDep {
 const createClientStorage =
   (
     deps: ClockDep &
+      DbSchemaDep &
       GetSyncOwnerDep &
       RandomDep &
       SqliteDep &
@@ -484,7 +488,7 @@ const createClientStorage =
         const ownerId = ownerIdBytesToOwnerId(ownerIdBytes);
 
         // Everything is sync now, but we will need async crypto in the future.
-        const writeResult = await mutex.withLock<
+        const result = await mutex.withLock<
           boolean,
           | AbortError
           | ProtocolInvalidDataError
@@ -536,11 +540,11 @@ const createClientStorage =
             }
 
             if (isNonEmptyReadonlyArray(messages)) {
-              const applyMessagesResult = applyMessages({ ...deps, storage })(
+              const result = applyMessages({ ...deps, storage })(
                 owner.id,
                 messages,
               );
-              if (!applyMessagesResult.ok) return applyMessagesResult;
+              if (!result.ok) return result;
             }
 
             return deps.clock.save(clockTimestamp);
@@ -551,9 +555,9 @@ const createClientStorage =
           return ok(true);
         })();
 
-        if (!writeResult.ok) {
-          if (writeResult.error.type !== "AbortError") {
-            config.onError(writeResult.error);
+        if (!result.ok) {
+          if (result.error.type !== "AbortError") {
+            config.onError(result.error);
           }
           return err<StorageWriteError>({ type: "StorageWriteError", ownerId });
         }
@@ -569,22 +573,30 @@ const createClientStorage =
         if (!owner) return null;
 
         const result = deps.sqlite.exec<{
-          table: string;
-          id: IdBytes;
-          column: string;
-          value: SqliteValue;
+          readonly table: string;
+          readonly id: IdBytes;
+          readonly column: string;
+          readonly value: SqliteValue;
         }>(sql`
           select "table", "id", "column", "value"
           from evolu_history
+          where "ownerId" = ${ownerId} and "timestamp" = ${timestamp}
+          union all
+          select "table", "id", "column", "value"
+          from evolu_message_quarantine
           where "ownerId" = ${ownerId} and "timestamp" = ${timestamp};
         `);
+
         if (!result.ok) {
           config.onError(result.error);
           return null;
         }
 
         const { rows } = result.value;
-        assertNonEmptyReadonlyArray(rows, "Every timestamp must have rows");
+        assertNonEmptyReadonlyArray(
+          rows,
+          "Every timestamp must have rows in evolu_history or quarantine",
+        );
 
         const { table, id } = firstInArray(rows);
         const values = createRecord<string, SqliteValue>();
@@ -687,7 +699,7 @@ export const applyLocalOnlyChange =
   };
 
 const applyMessages =
-  (deps: ClientStorageDep & ClockDep & RandomDep & SqliteDep) =>
+  (deps: ClientStorageDep & ClockDep & DbSchemaDep & RandomDep & SqliteDep) =>
   (
     ownerId: OwnerId,
     messages: NonEmptyReadonlyArray<CrdtMessage>,
@@ -703,51 +715,40 @@ const applyMessages =
     let { firstTimestamp, lastTimestamp } = usage.value;
 
     for (const { timestamp, change } of messages) {
-      const timestampBytes = timestampToTimestampBytes(timestamp);
-      const idBytes = idToIdBytes(change.id);
       const columns = dbChangeToColumns(change, timestampToDateIso(timestamp));
+      const idBytes = idToIdBytes(change.id);
+      const timestampBytes = timestampToTimestampBytes(timestamp);
 
       for (const [column, value] of columns) {
-        const updateAppTable = deps.sqlite.exec(sql.prepared`
-          with
-            existingTimestamp as (
-              select 1
-              from evolu_history
-              where
-                "ownerId" = ${ownerIdBytes}
-                and "table" = ${change.table}
-                and "id" = ${idBytes}
-                and "column" = ${column}
-                and "timestamp" >= ${timestampBytes}
-              limit 1
-            )
-          insert into ${sql.identifier(change.table)}
-            ("ownerId", "id", ${sql.identifier(column)})
-          select ${ownerId}, ${change.id}, ${value}
-          where not exists (select 1 from existingTimestamp)
-          on conflict ("ownerId", "id") do update
-            set ${sql.identifier(column)} = ${value}
-            where not exists (select 1 from existingTimestamp);
-        `);
-
-        if (!updateAppTable.ok) return updateAppTable;
-
-        const insertHistory = deps.sqlite.exec(sql.prepared`
-          insert into evolu_history
-            ("ownerId", "table", "id", "column", "value", "timestamp")
-          values
-            (
-              ${ownerIdBytes},
-              ${change.table},
-              ${idBytes},
-              ${column},
-              ${value},
-              ${timestampBytes}
-            )
-          on conflict do nothing;
-        `);
-
-        if (!insertHistory.ok) return insertHistory;
+        if (validateColumnValue(deps)(change.table, column, value)) {
+          const result = applyColumnChange(deps)(
+            ownerIdBytes,
+            ownerId,
+            change.table,
+            idBytes,
+            change.id,
+            column,
+            value,
+            timestampBytes,
+          );
+          if (!result.ok) return result;
+        } else {
+          const result = deps.sqlite.exec(sql.prepared`
+            insert into evolu_message_quarantine
+              ("ownerId", "timestamp", "table", "id", "column", "value")
+            values
+              (
+                ${ownerIdBytes},
+                ${timestampBytes},
+                ${change.table},
+                ${idBytes},
+                ${column},
+                ${value}
+              )
+            on conflict do nothing;
+          `);
+          if (!result.ok) return result;
+        }
       }
 
       let strategy;
@@ -757,26 +758,149 @@ const applyMessages =
         lastTimestamp,
       );
 
-      const insertTimestamp = deps.storage.insertTimestamp(
+      const result = deps.storage.insertTimestamp(
         ownerIdBytes,
         timestampBytes,
         strategy,
       );
-      if (!insertTimestamp.ok) return insertTimestamp;
+      if (!result.ok) return result;
     }
 
     /**
-     * TODO: Implement proper storedBytes tracking for client using encrypted
-     * message sizes (need to figure out how to reuse received or postpone
-     * client...).
+     * TODO: Implement proper storedBytes tracking for client using received and
+     * sent encrypted message sizes.
      */
-    const updateUsage = updateOwnerUsage(deps)(
+    return updateOwnerUsage(deps)(
       ownerIdBytes,
       1 as PositiveInt, // Placeholder until proper tracking implemented
       firstTimestamp,
       lastTimestamp,
     );
-    if (!updateUsage.ok) return updateUsage;
+  };
+
+/**
+ * System columns that can appear in sync messages. Excludes `ownerId` because
+ * it's handled separately (stored per-row, not per-column in messages).
+ */
+const systemColumnsWithoutOwnerId = systemColumns.difference(
+  new Set(["ownerId"]),
+);
+
+const validateColumnValue =
+  (deps: DbSchemaDep) =>
+  (table: string, column: string, _value: SqliteValue): boolean => {
+    const schemaColumns = getProperty(deps.dbSchema.tables, table);
+    return (
+      schemaColumns != null &&
+      (systemColumnsWithoutOwnerId.has(column) || schemaColumns.has(column))
+    );
+  };
+
+const applyColumnChange =
+  (deps: SqliteDep) =>
+  (
+    ownerIdBytes: OwnerIdBytes,
+    ownerId: OwnerId,
+    table: string,
+    idBytes: IdBytes,
+    id: Id,
+    column: string,
+    value: SqliteValue,
+    timestampBytes: TimestampBytes,
+  ): Result<void, SqliteError> => {
+    const result = deps.sqlite.exec(sql.prepared`
+      with
+        existingTimestamp as (
+          select 1
+          from evolu_history
+          where
+            "ownerId" = ${ownerIdBytes}
+            and "table" = ${table}
+            and "id" = ${idBytes}
+            and "column" = ${column}
+            and "timestamp" >= ${timestampBytes}
+          limit 1
+        )
+      insert into ${sql.identifier(table)}
+        ("ownerId", "id", ${sql.identifier(column)})
+      select ${ownerId}, ${id}, ${value}
+      where not exists (select 1 from existingTimestamp)
+      on conflict ("ownerId", "id") do update
+        set ${sql.identifier(column)} = ${value}
+        where not exists (select 1 from existingTimestamp);
+    `);
+    if (!result.ok) return result;
+
+    {
+      const result = deps.sqlite.exec(sql.prepared`
+        insert into evolu_history
+          ("ownerId", "table", "id", "column", "value", "timestamp")
+        values
+          (
+            ${ownerIdBytes},
+            ${table},
+            ${idBytes},
+            ${column},
+            ${value},
+            ${timestampBytes}
+          )
+        on conflict do nothing;
+      `);
+      if (!result.ok) return result;
+    }
+
+    return ok();
+  };
+
+/**
+ * Attempts to apply quarantined messages that may now be valid after a schema
+ * update. Messages are quarantined when they reference tables or columns that
+ * don't exist in the current schema (e.g., from a newer app version).
+ */
+export const tryApplyQuarantinedMessages =
+  (deps: DbSchemaDep & SqliteDep) => (): Result<void, SqliteError> => {
+    const rows = deps.sqlite.exec<{
+      readonly ownerId: OwnerIdBytes;
+      readonly timestamp: TimestampBytes;
+      readonly table: string;
+      readonly id: IdBytes;
+      readonly column: string;
+      readonly value: SqliteValue;
+    }>(sql`
+      select "ownerId", "timestamp", "table", "id", "column", "value"
+      from evolu_message_quarantine;
+    `);
+    if (!rows.ok) return rows;
+
+    for (const row of rows.value.rows) {
+      if (!validateColumnValue(deps)(row.table, row.column, row.value))
+        continue;
+
+      const result = applyColumnChange(deps)(
+        row.ownerId,
+        ownerIdBytesToOwnerId(row.ownerId),
+        row.table,
+        row.id,
+        idBytesToId(row.id),
+        row.column,
+        row.value,
+        row.timestamp,
+      );
+      if (!result.ok) return result;
+
+      {
+        const result = deps.sqlite.exec(sql`
+          delete from evolu_message_quarantine
+          where
+            "ownerId" = ${row.ownerId}
+            and "timestamp" = ${row.timestamp}
+            and "table" = ${row.table}
+            and "id" = ${row.id}
+            and "column" = ${row.column};
+        `);
+        if (!result.ok) return result;
+      }
+    }
 
     return ok();
   };

package/src/local-first/index.ts

@@ -5,7 +5,6 @@
  */
 
 export * from "./Db.js";
-export * from "./Diff.js";
 export * from "./Evolu.js";
 export * from "./Owner.js";
 export * from "./Platform.js";

package/dist/src/local-first/Diff.d.ts

@@ -1,43 +0,0 @@
-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 a cryptographically random Evolu Id, ensuring uniqueness
- * and 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 & import("../Brand.js").Brand<"Id">;
-export declare const parseSqliteJsonArray: <T>(arr: ReadonlyArray<T>) => ReadonlyArray<T>;
-//# sourceMappingURL=Diff.d.ts.map

package/dist/src/local-first/Diff.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Diff.d.ts","sourceRoot":"","sources":["../../../src/local-first/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,4CAE/B,CAAC;AAEH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EACpC,KAAK,aAAa,CAAC,CAAC,CAAC,KACpB,aAAa,CAAC,CAAC,CAMjB,CAAC"}

package/dist/src/local-first/Diff.js

@@ -1,97 +0,0 @@
-import { createRandomBytes } from "../Crypto.js";
-import { createRecord, isPlainObject } from "../Object.js";
-import { orderUint8Array } from "../Order.js";
-import { createId, 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 a cryptographically random Evolu Id, ensuring uniqueness
- * and 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 = createId({
-    randomBytes: createRandomBytes(),
-});
-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 = createRecord();
-    for (const key in obj) {
-        result[key] = parse(obj[key]);
-    }
-    return result;
-};

package/src/local-first/Diff.ts

@@ -1,144 +0,0 @@
-import { createRandomBytes } from "../Crypto.js";
-import { createRecord, isPlainObject, ReadonlyRecord } from "../Object.js";
-import { orderUint8Array } from "../Order.js";
-import { SqliteValue } from "../Sqlite.js";
-import { createId, String } from "../Type.js";
-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 const applyPatches = (
-  patches: ReadonlyArray<Patch>,
-  current: ReadonlyArray<Row>,
-): ReadonlyArray<Row> =>
-  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: ReadonlyArray<Row> | undefined,
-  nextRows: ReadonlyArray<Row>,
-): ReadonlyArray<Patch> => {
-  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: Array<ReplaceAtPatch> = [];
-
-  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] as SqliteValue, nextRow[key] as SqliteValue)
-      ) {
-        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: SqliteValue, b: SqliteValue): boolean => {
-  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 a cryptographically random Evolu Id, ensuring uniqueness
- * and 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 = createId({
-  randomBytes: createRandomBytes(),
-});
-
-export const parseSqliteJsonArray = <T>(
-  arr: ReadonlyArray<T>,
-): ReadonlyArray<T> => {
-  const result = new Array<T>(arr.length);
-  for (let i = 0; i < arr.length; ++i) {
-    result[i] = parse(arr[i]) as T;
-  }
-  return result;
-};
-
-const parse = (obj: unknown): unknown => {
-  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: ReadonlyRecord<string, unknown>,
-): ReadonlyRecord<string, unknown> => {
-  const result = createRecord();
-  for (const key in obj) {
-    result[key] = parse(obj[key]);
-  }
-  return result as ReadonlyRecord<string, unknown>;
-};