@evolu/common 6.0.1-preview.33 → 6.0.1-preview.35

package/src/Evolu/Schema.ts

@@ -14,6 +14,7 @@ import {
 import {
   AnyType,
   array,
+  createIdFromString,
   DateIso,
   IdBytes,
   InferErrors,
@@ -40,7 +41,7 @@ import { Simplify } from "../Types.js";
 import { AppOwner, OwnerId } from "./Owner.js";
 import { Query, Row } from "./Query.js";
 import { CrdtMessage, DbChange } from "./Storage.js";
-import { TimestampBytes } from "./Timestamp.js";
+import { Timestamp, TimestampBytes } from "./Timestamp.js";
 
 /**
  * Defines the schema of an Evolu database.
@@ -92,17 +93,17 @@ export type EvoluSchema = ReadonlyRecord<
  *
  * 1. All tables must have an 'id' column
  * 2. The 'id' column must be a branded ID type (created with id() function)
- * 3. Tables cannot use default column names (createdAt, updatedAt, isDeleted)
+ * 3. Tables cannot use system column names (createdAt, updatedAt, isDeleted)
  * 4. All column types must be compatible with SQLite (extend SqliteValue)
  */
 export type ValidateSchema<S extends EvoluSchema> =
   ValidateSchemaHasId<S> extends never
     ? ValidateIdColumnType<S> extends never
-      ? ValidateNoDefaultColumns<S> extends never
+      ? ValidateNoSystemColumns<S> extends never
         ? ValidateColumnTypes<S> extends never
           ? S
           : ValidateColumnTypes<S>
-        : ValidateNoDefaultColumns<S>
+        : ValidateNoSystemColumns<S>
       : ValidateIdColumnType<S>
     : ValidateSchemaHasId<S>;
 
@@ -126,13 +127,17 @@ export type ValidateIdColumnType<S extends EvoluSchema> =
       : never
     : never;
 
-export type ValidateNoDefaultColumns<S extends EvoluSchema> =
+export type ValidateNoSystemColumns<S extends EvoluSchema> =
   keyof S extends infer TableName
     ? TableName extends keyof S
       ? keyof S[TableName] extends infer ColumnName
         ? ColumnName extends keyof S[TableName]
-          ? ColumnName extends "createdAt" | "updatedAt" | "isDeleted"
-            ? SchemaValidationError<`Table "${TableName & string}" uses default column name "${ColumnName & string}". Default columns (createdAt, updatedAt, isDeleted) are added automatically.`>
+          ? ColumnName extends
+              | "createdAt"
+              | "updatedAt"
+              | "isDeleted"
+              | "ownerId"
+            ? SchemaValidationError<`Table "${TableName & string}" uses system column name "${ColumnName & string}". System columns (createdAt, updatedAt, isDeleted, ownerId) are added automatically.`>
             : never
           : never
         : never
@@ -189,13 +194,10 @@ export type CreateQuery<S extends EvoluSchema> = <R extends Row>(
       Kysely.Kysely<
         {
           [Table in keyof S]: {
-            readonly [Column in keyof S[Table]]: Column extends
-              | "id"
-              | "createdAt"
-              | "updatedAt"
+            readonly [Column in keyof S[Table]]: Column extends "id"
               ? InferType<S[Table][Column]>
               : InferType<S[Table][Column]> | null;
-          } & DefaultColumns;
+          } & SystemColumns;
         } & {
           readonly evolu_history: {
             readonly timestamp: TimestampBytes;
@@ -213,21 +215,23 @@ export type CreateQuery<S extends EvoluSchema> = <R extends Row>(
 ) => Query<Simplify<R>>;
 
 /**
- * Default columns automatically added to all tables.
+ * System columns that are implicitly defined by Evolu.
  *
- * - `createdAt`: Set by Evolu when `insert` is called, or can be custom with
- *   `upsert`.
- * - `updatedAt`: Always set by Evolu, derived from {@link CrdtMessage} timestamp.
- *   If you defer sync to avoid leaking time activity, use a custom column to
- *   preserve real update time.
- * - `isDeleted`: Soft delete flag.
+ * - `createdAt`: Set by Evolu on row creation, derived from {@link Timestamp}.
+ * - `updatedAt`: Set by Evolu on every row change, derived from {@link Timestamp}.
+ * - `isDeleted`: Soft delete flag created by Evolu and used by the developer to
+ *   mark rows as deleted.
+ * - `ownerId`: Represents ownership and logically partitions the database.
  */
-export const DefaultColumns = object({
+export const SystemColumns = object({
   createdAt: DateIso,
   updatedAt: DateIso,
   isDeleted: nullOr(SqliteBoolean),
+  ownerId: OwnerId,
 });
-export type DefaultColumns = typeof DefaultColumns.Type;
+export type SystemColumns = typeof SystemColumns.Type;
+
+export const systemColumns = Object.keys(SystemColumns.props);
 
 export type MutationKind = "insert" | "update" | "upsert";
 
@@ -311,7 +315,8 @@ export interface MutationChange extends DbChange {
 
 /**
  * Type Factory to create insertable {@link Type}. It makes nullable Types
- * optional, omits Id, and ensures the {@link maxMutationSize}.
+ * optional (so they are not required), omits Id, and ensures the
+ * {@link maxMutationSize}.
  *
  * ### Example
  *
@@ -341,7 +346,7 @@ export type Insertable<Props extends Record<string, AnyType>> = InferInput<
 
 /**
  * Type Factory to create updateable {@link Type}. It makes everything except for
- * the `id` column partial (i.e. optional) and ensures the
+ * the `id` column optional (so they are not required) and ensures the
  * {@link maxMutationSize}.
  *
  * ### Example
@@ -377,9 +382,15 @@ export type Updateable<Props extends Record<string, AnyType>> = InferInput<
 >;
 
 /**
- * Type Factory to create upsertable Type. It makes nullable Types optional,
- * includes optional default columns (createdAt, isDeleted), and ensures the
- * {@link maxMutationSize}.
+ * Type Factory to create an upsertable Type. It makes nullable Types optional
+ * (so they are not required) and ensures the {@link maxMutationSize}.
+ *
+ * Upsert is like insert, except it requires an ID. It's useful for inserting
+ * rows with external ID via {@link createIdFromString}.
+ *
+ * Note that it's not possible to upsert a row with `createdAt` nor `updatedAt`,
+ * because they are derived from {@link CrdtMessage} timestamp. For external
+ * createdAt, use a different column.
  *
  * ### Example
  *
@@ -389,7 +400,6 @@ export type Updateable<Props extends Record<string, AnyType>> = InferInput<
  * const todo = UpsertableTodo.from({
  *   id,
  *   title,
- *   createdAt: "2023-01-01T00:00:00.000Z",
  * });
  * if (!todo.ok) return; // handle errors
  * ```
@@ -399,7 +409,6 @@ export const upsertable = <Props extends Record<string, AnyType>>(
 ): ValidMutationSize<UpsertableProps<Props>> => {
   const propsWithDefaults = {
     ...props,
-    createdAt: optional(DateIso),
     isDeleted: optional(SqliteBoolean),
   };
   return validMutationSize(nullableToOptional(propsWithDefaults));
@@ -408,7 +417,6 @@ export const upsertable = <Props extends Record<string, AnyType>>(
 export type UpsertableProps<Props extends Record<string, AnyType>> =
   NullableToOptionalProps<
     Props & {
-      createdAt: OptionalType<typeof DateIso>;
       isDeleted: OptionalType<typeof SqliteBoolean>;
     }
   >;
@@ -534,10 +542,7 @@ export const ensureDbSchema =
         (t) => t.name === newTable.name,
       );
       if (!currentTable) {
-        queries.push({
-          sql: createTableWithDefaultColumns(newTable.name, newTable.columns),
-          parameters: [],
-        });
+        queries.push(createAppTable(newTable));
       } else {
         newTable.columns
           .filter((newColumn) => !currentTable.columns.includes(newColumn))
@@ -583,24 +588,23 @@ export const ensureDbSchema =
     return ok();
   };
 
-const createTableWithDefaultColumns = (
-  tableName: string,
-  columns: ReadonlyArray<string>,
-): SafeSql =>
-  `
-    create table ${sql.identifier(tableName).sql} (
-      "id" text primary key,
-      ${columns
-        // Add default columns.
-        .concat(["createdAt", "updatedAt", "isDeleted"])
+const createAppTable = (table: DbTable) => sql`
+  create table ${sql.identifier(table.name)} (
+    "id" text,
+    ${sql.raw(
+      `${systemColumns
+        .concat(table.columns)
         .filter((c) => c !== "id")
-        // "A column with affinity BLOB does not prefer one storage class over another
-        // and no attempt is made to coerce data from one storage class into another."
-        // https://www.sqlite.org/datatype3.html
-        .map((name) => `${sql.identifier(name).sql} blob`)
-        .join(", ")}
-    );
-  ` as SafeSql;
+        // With strict tables and any type, data is preserved exactly as received
+        // without any type affinity coercion. This allows storing any data type
+        // while maintaining strict null enforcement for primary key columns.
+        .map((name) => `${sql.identifier(name).sql} any`)
+        .join(", ")}`,
+    )},
+    primary key ("ownerId", "id")
+  )
+  without rowid, strict;
+`;
 
 // https://kysely.dev/docs/recipes/splitting-query-building-and-execution
 export const kysely = new Kysely.Kysely({

package/src/Evolu/Storage.ts

@@ -9,17 +9,21 @@ import { Brand } from "../Brand.js";
 import { concatBytes } from "../Buffer.js";
 import { decrement } from "../Number.js";
 import { RandomDep } from "../Random.js";
-import { ok, Result } from "../Result.js";
+import { err, ok, Result } from "../Result.js";
 import { sql, SqliteDep, SqliteError, SqliteValue } from "../Sqlite.js";
 import { MaybeAsync } from "../Task.js";
 import {
+  Boolean,
+  brand,
   Id,
   Int64String,
   NonNegativeInt,
+  nullOr,
   object,
   PositiveInt,
   record,
   String,
+  TypeError,
 } from "../Type.js";
 import {
   BaseOwnerError,
@@ -28,6 +32,7 @@ import {
   OwnerIdBytes,
   OwnerWriteKey,
 } from "./Owner.js";
+import { systemColumns } from "./Schema.js";
 import { orderTimestampBytes, Timestamp, TimestampBytes } from "./Timestamp.js";
 
 export interface StorageConfig {
@@ -248,6 +253,36 @@ export interface CrdtMessage {
   readonly change: DbChange;
 }
 
+export const DbChangeValues = record(String, SqliteValue);
+export type DbChangeValues = typeof DbChangeValues.Type;
+
+// "createdAt" and "updatedAt" are derived from Timestamp.
+// "id" and "isDeleted" are encoded separately to save bytes
+// "ownerId" is part of the protocol message
+const forbiddenSystemColumns = systemColumns.concat("id");
+
+export const ValidDbChangeValues = brand(
+  "ValidDbChangeValues",
+  DbChangeValues,
+  (value) => {
+    const invalidColumns = forbiddenSystemColumns.filter((key) => key in value);
+    if (invalidColumns.length > 0)
+      return err<ValidDbChangeValuesError>({
+        type: "ValidDbChangeValues",
+        value,
+        invalidColumns,
+      });
+
+    return ok(value);
+  },
+);
+export type ValidDbChangeValues = typeof ValidDbChangeValues.Type;
+
+export interface ValidDbChangeValuesError
+  extends TypeError<"ValidDbChangeValues"> {
+  readonly invalidColumns: ReadonlyArray<string>;
+}
+
 /**
  * A DbChange is a change to a table row. Together with a unique
  * {@link Timestamp}, it forms a {@link CrdtMessage}.
@@ -255,7 +290,9 @@ export interface CrdtMessage {
 export const DbChange = object({
   table: String,
   id: Id,
-  values: record(String, SqliteValue),
+  values: ValidDbChangeValues,
+  isInsert: Boolean,
+  isDelete: nullOr(Boolean),
 });
 export type DbChange = typeof DbChange.Type;
 

package/src/Evolu/Sync.ts

@@ -19,12 +19,27 @@ import { objectToEntries } from "../Object.js";
 import { RandomDep } from "../Random.js";
 import { createResources } from "../Resources.js";
 import { err, ok, Result } from "../Result.js";
-import { sql, SqliteDep, SqliteError, SqliteValue } from "../Sqlite.js";
+import {
+  booleanToSqliteBoolean,
+  sql,
+  SqliteBoolean,
+  sqliteBooleanToBoolean,
+  SqliteDep,
+  SqliteError,
+  sqliteFalse,
+  SqliteValue,
+} from "../Sqlite.js";
 import { AbortError, createMutex } from "../Task.js";
 import { TimeDep } from "../Time.js";
-import { IdBytes, idBytesToId, idToIdBytes, PositiveInt } from "../Type.js";
+import {
+  DateIso,
+  IdBytes,
+  idBytesToId,
+  idToIdBytes,
+  PositiveInt,
+} from "../Type.js";
 import { CreateWebSocketDep, WebSocket } from "../WebSocket.js";
-import type { PostMessageDep } from "./Db.js";
+import type { AppOwnerDep, PostMessageDep } from "./Db.js";
 import {
   AppOwner,
   OwnerEncryptionKey,
@@ -74,8 +89,8 @@ import {
   TimestampCounterOverflowError,
   TimestampDriftError,
   TimestampTimeOutOfRangeError,
+  timestampToDateIso,
   timestampToTimestampBytes,
-  timestampToTimestampString,
 } from "./Timestamp.js";
 
 export interface Sync extends Disposable {
@@ -341,7 +356,10 @@ export const createSync =
           clockTimestamp = nextTimestamp.value;
 
           const { ownerId = config.appOwner.id, ...dbChange } = change;
-          const message = { timestamp: clockTimestamp, change: dbChange };
+          const message: CrdtMessage = {
+            timestamp: clockTimestamp,
+            change: dbChange,
+          };
 
           const messages = ownerMessages.get(ownerId);
           if (messages) messages.push(message);
@@ -397,7 +415,6 @@ export interface ClockDep {
   readonly clock: Clock;
 }
 
-// HLC
 export interface Clock {
   readonly get: () => Timestamp;
   readonly save: (timestamp: Timestamp) => Result<void, SqliteError>;
@@ -413,9 +430,9 @@ export const createClock =
       save: (timestamp) => {
         currentTimestamp = timestamp;
 
-        const timestampString = timestampToTimestampString(timestamp);
         const result = deps.sqlite.exec(sql.prepared`
-          update evolu_config set "clock" = ${timestampString};
+          update evolu_config
+          set "clock" = ${timestampToTimestampBytes(timestamp)};
         `);
         if (!result.ok) return result;
 
@@ -587,20 +604,37 @@ const createClientStorage =
 
         const { table, id } = rows[0];
         const values: Record<string, SqliteValue> = {};
+        let isInsert = false;
+        let isDelete: boolean | null = null;
 
         for (const r of rows) {
           assert(r.table === table, "All rows must have the same table");
           assert(eqArrayNumber(r.id, id), "All rows must have the same Id");
-          values[r.column] = r.value;
+          switch (r.column) {
+            case "createdAt":
+              isInsert = true;
+              break;
+            case "isDeleted":
+              assert(
+                SqliteBoolean.is(r.value),
+                "isDeleted column must contain a valid SqliteBoolean (0 or 1)",
+              );
+              isDelete = sqliteBooleanToBoolean(r.value);
+              break;
+            default:
+              values[r.column] = r.value;
+          }
         }
 
         const message: CrdtMessage = {
           timestamp: timestampBytesToTimestamp(timestamp),
-          change: {
+          change: DbChange.orThrow({
             table: rows[0].table,
             id: idBytesToId(rows[0].id),
             values,
-          },
+            isInsert,
+            isDelete,
+          }),
         };
 
         return encodeAndEncryptDbChange(deps)(message, owner.encryptionKey);
@@ -618,35 +652,32 @@ const createTransportKey = (transportConfig: OwnerTransport): TransportKey => {
 };
 
 export const applyLocalOnlyChange =
-  (deps: SqliteDep & TimeDep) =>
+  (deps: SqliteDep & TimeDep & AppOwnerDep) =>
   (change: MutationChange): Result<void, SqliteError> => {
-    const dbChange: DbChange = {
-      table: change.table,
-      id: change.id,
-      values: change.values,
-    };
-
-    const isDeletion =
-      "isDeleted" in dbChange.values && dbChange.values.isDeleted === 1;
-
-    if (isDeletion) {
+    if (change.isDelete) {
       const result = deps.sqlite.exec(sql`
-        delete from ${sql.identifier(dbChange.table)}
-        where id = ${dbChange.id};
+        delete from ${sql.identifier(change.table)}
+        where id = ${change.id};
       `);
       if (!result.ok) return result;
     } else {
-      const date = new Date(deps.time.now()).toISOString();
+      const now = deps.time.nowIso();
+      const ownerId = deps.appOwner.id;
+
+      let entries = objectToEntries(change.values);
+      if (change.isDelete !== null) {
+        entries = [...entries, ["isDeleted", sqliteFalse]];
+      }
 
-      for (const [column, value] of objectToEntries(dbChange.values)) {
+      for (const [column, value] of entries) {
         const result = deps.sqlite.exec(sql.prepared`
-          insert into ${sql.identifier(dbChange.table)}
-            ("id", ${sql.identifier(column)}, createdAt, updatedAt)
-          values (${dbChange.id}, ${value}, ${date}, ${date})
-          on conflict ("id") do update
+          insert into ${sql.identifier(change.table)}
+            ("ownerId", "id", ${sql.identifier(column)}, createdAt, updatedAt)
+          values (${ownerId}, ${change.id}, ${value}, ${now}, ${now})
+          on conflict ("ownerId", "id") do update
             set
               ${sql.identifier(column)} = ${value},
-              updatedAt = ${date};
+              updatedAt = ${now};
         `);
         if (!result.ok) return result;
       }
@@ -672,7 +703,8 @@ const applyMessages =
     let { firstTimestamp, lastTimestamp } = usageResult.value;
 
     for (const message of messages) {
-      const result1 = applyMessageToAppTable(deps)(ownerIdBytes, message);
+      const date = timestampToDateIso(message.timestamp);
+      const result1 = applyMessageToAppTable(deps)(ownerIdBytes, message, date);
       if (!result1.ok) return result1;
 
       const timestamp = timestampToTimestampBytes(message.timestamp);
@@ -688,6 +720,7 @@ const applyMessages =
         ownerIdBytes,
         message,
         strategy,
+        date,
       );
       if (!result2.ok) return result2;
     }
@@ -710,32 +743,36 @@ const applyMessages =
 
 const applyMessageToAppTable =
   (deps: SqliteDep) =>
-  (ownerId: OwnerIdBytes, message: CrdtMessage): Result<void, SqliteError> => {
-    const timestamp = timestampToTimestampBytes(message.timestamp);
-    const updatedAt = new Date(message.timestamp.millis).toISOString();
+  (
+    ownerIdBytes: OwnerIdBytes,
+    message: CrdtMessage,
+    date: DateIso,
+  ): Result<void, SqliteError> => {
+    const ownerId = ownerIdBytesToOwnerId(ownerIdBytes);
+    const columns = dbChangeToColumns(message.change, date);
 
-    for (const [column, value] of objectToEntries(message.change.values)) {
+    for (const [column, value] of columns) {
       const result = deps.sqlite.exec(sql.prepared`
         with
           existingTimestamp as (
             select 1
             from evolu_history
             where
-              "ownerId" = ${ownerId}
+              "ownerId" = ${ownerIdBytes}
               and "table" = ${message.change.table}
               and "id" = ${idToIdBytes(message.change.id)}
               and "column" = ${column}
-              and "timestamp" >= ${timestamp}
+              and "timestamp" >= ${timestampToTimestampBytes(message.timestamp)}
             limit 1
           )
         insert into ${sql.identifier(message.change.table)}
-          ("id", ${sql.identifier(column)}, updatedAt)
-        select ${message.change.id}, ${value}, ${updatedAt}
+          ("ownerId", "id", ${sql.identifier(column)}, updatedAt)
+        select ${ownerId}, ${message.change.id}, ${value}, ${date}
         where not exists (select 1 from existingTimestamp)
-        on conflict ("id") do update
+        on conflict ("ownerId", "id") do update
           set
             ${sql.identifier(column)} = ${value},
-            updatedAt = ${updatedAt}
+            updatedAt = ${date}
           where not exists (select 1 from existingTimestamp);
       `);
 
@@ -751,6 +788,7 @@ export const applyMessageToTimestampAndHistoryTables =
     ownerId: OwnerIdBytes,
     message: CrdtMessage,
     strategy: StorageInsertTimestampStrategy,
+    date: DateIso,
   ): Result<void, SqliteError> => {
     const timestamp = timestampToTimestampBytes(message.timestamp);
     const id = idToIdBytes(message.change.id);
@@ -758,7 +796,9 @@ export const applyMessageToTimestampAndHistoryTables =
     const result = deps.storage.insertTimestamp(ownerId, timestamp, strategy);
     if (!result.ok) return result;
 
-    for (const [column, value] of Object.entries(message.change.values)) {
+    const columns = dbChangeToColumns(message.change, date);
+
+    for (const [column, value] of columns) {
       const result = deps.sqlite.exec(sql.prepared`
         insert into evolu_history
           ("ownerId", "table", "id", "column", "value", "timestamp")
@@ -779,6 +819,20 @@ export const applyMessageToTimestampAndHistoryTables =
     return ok();
   };
 
+const dbChangeToColumns = (
+  change: DbChange,
+  date: DateIso,
+): Array<[string, SqliteValue | DateIso]> => {
+  const entries = [...objectToEntries(change.values)];
+  if (change.isInsert) {
+    entries.push(["createdAt", date]);
+  }
+  if (change.isDelete !== null) {
+    entries.push(["isDeleted", booleanToSqliteBoolean(change.isDelete)]);
+  }
+  return entries;
+};
+
 /**
  * TODO: Rework for the new owners API.
  *

package/src/Evolu/Timestamp.ts

@@ -1,5 +1,3 @@
-import { assert } from "../Assert.js";
-import { Brand } from "../Brand.js";
 import { bytesToHex } from "../Buffer.js";
 import { RandomBytesDep } from "../Crypto.js";
 import { createEqObject, eqNumber, eqString } from "../Eq.js";
@@ -9,6 +7,7 @@ import { err, ok, Result } from "../Result.js";
 import { TimeDep } from "../Time.js";
 import {
   brand,
+  DateIso,
   InferType,
   lessThanOrEqualTo,
   NonNegativeInt,
@@ -192,29 +191,6 @@ export const createInitialTimestamp = (deps: RandomBytesDep): Timestamp => {
   return createTimestamp({ nodeId });
 };
 
-/** Sortable string representation of {@link Timestamp}. */
-export type TimestampString = string & Brand<"TimestampString">;
-
-export const timestampToTimestampString = (t: Timestamp): TimestampString =>
-  [
-    new Date(t.millis).toISOString(),
-    t.counter.toString(16).toUpperCase().padStart(4, "0"),
-    t.nodeId,
-  ].join("-") as TimestampString;
-
-export const timestampStringToTimestamp = (
-  timestampString: TimestampString,
-): Timestamp => {
-  const array = timestampString.split("-");
-  const timestamp = {
-    millis: Date.parse(array.slice(0, 3).join("-")).valueOf(),
-    counter: parseInt(array[3], 16),
-    nodeId: array[4],
-  };
-  assert(Timestamp.is(timestamp), "timestampString is malformed");
-  return timestamp;
-};
-
 const getNextMillis =
   (deps: TimeDep & TimestampConfigDep) =>
   (
@@ -361,3 +337,7 @@ export const timestampBytesToTimestamp = (
 };
 
 export const orderTimestampBytes: Order<TimestampBytes> = orderUint8Array;
+
+export const timestampToDateIso = (timestamp: Timestamp): DateIso =>
+  // `as DateIso` is safe because the timestamp is always valid
+  new Date(timestamp.millis).toISOString() as DateIso;

package/src/Object.ts

@@ -25,14 +25,22 @@ export type ReadonlyRecord<K extends keyof any, V> = Readonly<Record<K, V>>;
 type StringKeyOf<T> = Extract<keyof T, string>;
 
 /**
- * Converts a record to entries, preserving branded string key types (e.g.,
- * `type Id = 'id' & string`) via `StringKeyOf<T>`, unlike `Object.entries`
- * which widens keys to `string`.
+ * Like `Object.entries` but preserves branded keys.
+ *
+ * ### Example
+ *
+ * ```ts
+ * type UserId = string & { readonly __brand: "UserId" };
+ * const users: Record<UserId, string> = {};
+ * const entries = objectToEntries(users); // [UserId, string][]
+ * ```
  */
 export const objectToEntries = <T extends Record<string, any>>(
   record: T,
-): Array<[StringKeyOf<T>, T[StringKeyOf<T>]]> =>
-  Object.entries(record) as Array<[StringKeyOf<T>, T[StringKeyOf<T>]]>;
+): ReadonlyArray<[StringKeyOf<T>, T[StringKeyOf<T>]]> =>
+  Object.entries(record) as Array<
+    [StringKeyOf<T>, T[StringKeyOf<T>]]
+  > as ReadonlyArray<[StringKeyOf<T>, T[StringKeyOf<T>]]>;
 
 /**
  * Maps a `ReadonlyRecord<K, V>` to a new `ReadonlyRecord<K, U>`, preserving