@livestore/livestore 0.0.39 → 0.0.41-dev.0

package/src/cud.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from 'vitest'
+
+import { tables } from './__tests__/react/fixture.js'
+import { makeCudMutations } from './cud.js'
+import type { MutationEvent } from './index.js'
+
+describe('cud mutations', () => {
+  const cud = makeCudMutations(tables)
+
+  test('basic', () => {
+    expect(patchId(cud.todos.insert({ id: 't1', completed: true, text: 'Task 1' }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "bindValues": {
+            "completed": 1,
+            "id": "t1",
+            "text": "Task 1",
+          },
+          "sql": "INSERT  INTO todos (id, text, completed) VALUES ($id, $text, $completed)",
+          "writeTables": Set {
+            "todos",
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "livestore.RawSql",
+      }
+    `)
+
+    expect(patchId(cud.todos.update({ where: { id: 't1' }, values: { text: 'Task 1 - fixed' } })))
+      .toMatchInlineSnapshot(`
+        {
+          "args": {
+            "bindValues": {
+              "update_text": "Task 1 - fixed",
+              "where_id": "t1",
+            },
+            "sql": "UPDATE todos SET text = $update_text WHERE id = $where_id",
+            "writeTables": Set {
+              "todos",
+            },
+          },
+          "id": "00000000-0000-0000-0000-000000000000",
+          "mutation": "livestore.RawSql",
+        }
+      `)
+  })
+})
+
+const patchId = (muationEvent: MutationEvent.Any) => {
+  const id = `00000000-0000-0000-0000-000000000000`
+  return { ...muationEvent, id }
+}

package/src/{mutations.ts → cud.ts}

@@ -1,28 +1,34 @@
 import * as SqlQueries from '@livestore/sql-queries'
-import { pipe, ReadonlyRecord } from '@livestore/utils/effect'
 import type { SqliteDsl } from 'effect-db-schema'
 
 import type { RowResult } from './row-query.js'
-import type { LiveStoreSchema } from './schema/index.js'
+import { rawSqlMutation, type RawSqlMutationEvent } from './schema/index.js'
 import { getDefaultValuesEncoded, type TableDef } from './schema/table-def.js'
-import type { GetValForKey } from './utils/util.js'
+import { type GetValForKey, isIterable } from './utils/util.js'
 
-export const makeMutations = <TDbSchema extends SqliteDsl.DbSchema>(
-  schema: LiveStoreSchema<TDbSchema>,
-): Mutations<TDbSchema> => {
-  return Object.fromEntries(Array.from(schema.tables.values()).map(mutationsForTable)) as any
+export const makeCudMutations = <TTableDef extends TableDef>(
+  tables: Iterable<TTableDef> | Record<string, TTableDef>,
+): CudMutations<TTableDef> => {
+  const cudMutationRecord: CudMutations<TTableDef> = {} as any
+
+  const tables_ = isIterable(tables) ? tables : Object.values(tables)
+
+  for (const tableDef of tables_) {
+    const [tableName, cudMutation] = cudMutationsForTable(tableDef)
+    cudMutationRecord[tableName] = cudMutation as any
+  }
+
+  return cudMutationRecord
 }
 
-const mutationsForTable = <TTableDef extends TableDef>(tableDef: TTableDef): [string, Mutation<TTableDef>] => {
+const cudMutationsForTable = <TTableDef extends TableDef>(
+  tableDef: TTableDef,
+): [TTableDef['sqliteDef']['name'], CudMutation<TTableDef>] => {
   const table = tableDef.sqliteDef
   const writeTables = new Set([table.name])
   const api = {
     insert: (values_: any) => {
-      const defaultValues = getDefaultValuesEncoded(tableDef)
-      const values = pipe(
-        tableDef.sqliteDef.columns,
-        ReadonlyRecord.map((_, columnName) => values_?.[columnName] ?? defaultValues[columnName]),
-      )
+      const values = getDefaultValuesEncoded(tableDef, values_)
 
       const [sql, bindValues] = SqlQueries.insertRow({
         tableName: table.name,
@@ -30,7 +36,7 @@ const mutationsForTable = <TTableDef extends TableDef>(tableDef: TTableDef): [st
         options: { orReplace: false },
         values: values as any,
       })
-      return { eventType: 'livestore.RawSql', args: { sql, bindValues, writeTables } }
+      return rawSqlMutation({ sql, bindValues, writeTables })
     },
     update: ({ where, values }) => {
       const [sql, bindValues] = SqlQueries.updateRows({
@@ -39,7 +45,7 @@ const mutationsForTable = <TTableDef extends TableDef>(tableDef: TTableDef): [st
         where: where,
         updateValues: values,
       })
-      return { eventType: 'livestore.RawSql', args: { sql, bindValues, writeTables } }
+      return rawSqlMutation({ sql, bindValues, writeTables })
     },
     delete: ({ where }) => {
       const [sql, bindValues] = SqlQueries.deleteRows({
@@ -47,40 +53,35 @@ const mutationsForTable = <TTableDef extends TableDef>(tableDef: TTableDef): [st
         columns: table.columns,
         where: where,
       })
-      return { eventType: 'livestore.RawSql', args: { sql, bindValues, writeTables } }
+      return rawSqlMutation({ sql, bindValues, writeTables })
     },
-  } satisfies Mutation<TTableDef>
+  } satisfies CudMutation<TTableDef>
 
   return [tableDef.sqliteDef.name, api]
 }
 
-export type MutationEvent = {
-  eventType: 'livestore.RawSql'
-  args: { sql: string; bindValues: SqlQueries.BindValues; writeTables: Set<string> }
-}
-
 export type UpdateMutation<TTableDef extends TableDef> = (args: {
   // TODO also allow `id` if present in `TTableDef`
   where: Partial<RowResult<TTableDef>>
   values: Partial<RowResult<TTableDef>>
-}) => MutationEvent
+}) => RawSqlMutationEvent
 
 export type RowInsert<TTableDef extends TableDef> = TTableDef['isSingleColumn'] extends true
   ? GetValForKey<SqliteDsl.FromColumns.InsertRowDecoded<TTableDef['sqliteDef']['columns']>, 'value'>
   : SqliteDsl.FromColumns.InsertRowDecoded<TTableDef['sqliteDef']['columns']>
 
-export type InsertMutation<TTableDef extends TableDef> = (values: RowInsert<TTableDef>) => MutationEvent
+export type InsertMutation<TTableDef extends TableDef> = (values: RowInsert<TTableDef>) => RawSqlMutationEvent
 
 export type DeleteMutation<TTableDef extends TableDef> = (args: {
   where: Partial<RowResult<TTableDef>>
-}) => MutationEvent
+}) => RawSqlMutationEvent
 
-export type Mutation<TTableDef extends TableDef> = {
+export type CudMutation<TTableDef extends TableDef> = {
   insert: InsertMutation<TTableDef>
   update: UpdateMutation<TTableDef>
   delete: DeleteMutation<TTableDef>
 }
 
-export type Mutations<TDbSchema extends SqliteDsl.DbSchema> = {
-  [TTableName in keyof TDbSchema]: Mutation<TableDef<TDbSchema[TTableName]>>
+export type CudMutations<TTableDef extends TableDef> = {
+  [TTableName in TTableDef['sqliteDef']['name']]: CudMutation<Extract<TTableDef, { sqliteDef: { name: TTableName } }>>
 }

package/src/inMemoryDatabase.ts

@@ -138,7 +138,7 @@ export class InMemoryDatabase {
   execute(
     query: string,
     bindValues?: PreparedBindValues,
-    writeTables?: ReadonlyArray<string>,
+    writeTables?: ReadonlySet<string>,
     options?: { hasNoEffects?: boolean; otelContext?: otel.Context },
   ): { durationMs: number } {
     // console.debug('in-memory-db:execute', query, bindValues)
@@ -170,12 +170,7 @@ export class InMemoryDatabase {
             stmt.reset() // Reset is needed for next execution
           }
         } catch (error) {
-          shouldNeverHappen(
-            `Error executing query: ${error} \n ${JSON.stringify({
-              query,
-              bindValues,
-            })}`,
-          )
+          shouldNeverHappen(`Error executing query: ${error} \n ${JSON.stringify({ query, bindValues })}`)
         }
 
         if (options?.hasNoEffects !== true && !this.resultCache.ignoreQuery(query)) {

package/src/index.ts

@@ -13,23 +13,29 @@ export { LiveStoreSQLQuery, querySQL, type MapRows } from './reactiveQueries/sql
 export { LiveStoreGraphQLQuery, queryGraphQL } from './reactiveQueries/graphql.js'
 export { type GetAtomResult, type DbGraph, makeDbGraph, type LiveQuery } from './reactiveQueries/base-class.js'
 
-export { globalDbGraph } from './global-state.js'
+export { globalDbGraph, dynamicallyRegisteredTables } from './global-state.js'
 
 export { type RowResult, type RowResultEncoded, rowQuery, deriveColQuery } from './row-query.js'
 
-export * from './mutations.js'
+export * from './cud.js'
 
-export { defineAction, defineActions, makeSchema, DbSchema, ParseUtils } from './schema/index.js'
+export {
+  makeSchema,
+  DbSchema,
+  ParseUtils,
+  defineMutation,
+  rawSqlMutation,
+  makeMutationEventSchema,
+  makeMutationDefRecord,
+} from './schema/index.js'
 
 export type {
   LiveStoreSchema,
   InputSchema,
-  GetActionArgs,
-  GetApplyEventArgs,
-  ActionDefinition,
-  ActionDefinitions,
-  SQLWriteStatement,
   SchemaMetaRow,
+  MutationDef,
+  MutationEvent,
+  MutationDefMap,
 } from './schema/index.js'
 
 export { SqliteAst, SqliteDsl } from 'effect-db-schema'

package/src/migrations.ts

@@ -1,6 +1,6 @@
 import { Schema as EffectSchema } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
-import { SqliteAst } from 'effect-db-schema'
+import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 import { memoize } from 'lodash-es'
 
 import { dynamicallyRegisteredTables } from './global-state.js'
@@ -26,7 +26,7 @@ export const migrateDb = ({
     // TODO use schema migration definition from schema.ts instead
     sql`create table if not exists ${SCHEMA_META_TABLE} (tableName text primary key, schemaHash text, updatedAt text);`,
     undefined,
-    [],
+    new Set(),
     { otelContext },
   )
 
@@ -80,11 +80,11 @@ export const migrateTable = ({
   const columnSpec = makeColumnSpec(tableAst)
 
   // TODO need to possibly handle cascading deletes due to foreign keys
-  db.execute(sql`drop table if exists ${tableName}`, undefined, [], { otelContext })
-  db.execute(sql`create table if not exists ${tableName} (${columnSpec});`, undefined, [], { otelContext })
+  db.execute(sql`drop table if exists ${tableName}`, undefined, new Set(), { otelContext })
+  db.execute(sql`create table if not exists ${tableName} (${columnSpec});`, undefined, new Set(), { otelContext })
 
   for (const index of tableAst.indexes) {
-    db.execute(createIndexFromDefinition(tableName, index), undefined, [], { otelContext })
+    db.execute(createIndexFromDefinition(tableName, index), undefined, new Set(), { otelContext })
   }
 
   const updatedAt = getMemoizedTimestamp()
@@ -94,7 +94,7 @@ export const migrateTable = ({
         ON CONFLICT (tableName) DO UPDATE SET schemaHash = $schemaHash, updatedAt = $updatedAt;
     `,
     { $tableName: tableName, $schemaHash: schemaHash, $updatedAt: updatedAt } as unknown as PreparedBindValues,
-    [],
+    new Set(),
     { otelContext },
   )
 }
@@ -121,10 +121,13 @@ const toSqliteColumnSpec = (column: SqliteAst.Column) => {
   const defaultValueStr = (() => {
     if (column.default._tag === 'None') return ''
 
+    if (SqliteDsl.isSqlDefaultValue(column.default.value)) return `default ${column.default.value.sql}`
+
     const encodeValue = EffectSchema.encodeSync(column.schema)
     const encodedDefaultValue = encodeValue(column.default.value)
 
-    return columnTypeStr === 'text' ? `default '${encodedDefaultValue}'` : `default ${encodedDefaultValue}`
+    if (columnTypeStr === 'text') return `default '${encodedDefaultValue}'`
+    return `default ${encodedDefaultValue}`
   })()
 
   return `${column.name} ${columnTypeStr} ${nullableStr} ${defaultValueStr}`

package/src/query-info.ts

@@ -1,6 +1,7 @@
 import { notYetImplemented, shouldNeverHappen } from '@livestore/utils'
 import { Schema } from '@livestore/utils/effect'
 
+import { rawSqlMutation, type RawSqlMutationEvent } from './schema/mutations.js'
 import type { FromTable, TableDef } from './schema/table-def.js'
 
 /**
@@ -49,8 +50,6 @@ type GetJsonColumn<TTableDef extends TableDef> = keyof {
     : never]: {}
 }
 
-// type GetObjValues<TObj extends {}> = TObj[keyof TObj]
-
 export type UpdateValueForPath<TPath extends QueryInfo> = TPath extends { _tag: 'Row' }
   ? Partial<FromTable.RowDecodedAll<TPath['table']>>
   : TPath extends { _tag: 'Col' }
@@ -59,10 +58,10 @@ export type UpdateValueForPath<TPath extends QueryInfo> = TPath extends { _tag:
       ? { TODO: true }
       : never
 
-export const storeEventForQueryInfo = <TPath extends QueryInfo>(
+export const mutationForQueryInfo = <const TPath extends QueryInfo>(
   updatePath: TPath,
   value: UpdateValueForPath<TPath>,
-): StoreEvent => {
+): RawSqlMutationEvent => {
   if (updatePath._tag === 'ColJsonValue' || updatePath._tag === 'None') {
     return notYetImplemented('TODO')
   }
@@ -96,7 +95,5 @@ export const storeEventForQueryInfo = <TPath extends QueryInfo>(
   const sql = `UPDATE ${sqliteTableDef.name} SET ${updateClause} ${whereClause}`
   const writeTables = new Set<string>([updatePath.table.sqliteDef.name])
 
-  return { eventType: 'livestore.RawSql', args: { sql, bindValues, writeTables } }
+  return rawSqlMutation({ sql, bindValues, writeTables })
 }
-
-type StoreEvent = { eventType: string; args: any }

package/src/react/useAtom.ts

@@ -1,6 +1,6 @@
 import React from 'react'
 
-import { type QueryInfoCol, type QueryInfoRow, storeEventForQueryInfo } from '../query-info.js'
+import { mutationForQueryInfo, type QueryInfoCol, type QueryInfoRow } from '../query-info.js'
 import type { LiveQuery } from '../reactiveQueries/base-class.js'
 import { useStore } from './LiveStoreContext.js'
 import { useQueryRef } from './useQuery.js'
@@ -17,7 +17,7 @@ export const useAtom = <TQuery extends LiveQuery<any, QueryInfoRow<any> | QueryI
     return (newValueOrFn: any) => {
       const newValue = typeof newValueOrFn === 'function' ? newValueOrFn(query$Ref.current) : newValueOrFn
 
-      store.applyEvents([storeEventForQueryInfo(query$.queryInfo!, newValue)])
+      store.mutate(mutationForQueryInfo(query$.queryInfo!, newValue))
     }
   }, [query$.queryInfo, query$Ref, store])
 

package/src/{__tests__/react → react}/useQuery.test.tsx

@@ -2,15 +2,15 @@ import { act, renderHook } from '@testing-library/react'
 import React from 'react'
 import { describe, expect, it } from 'vitest'
 
-import * as LiveStoreReact from '../../react/index.js'
-import { querySQL } from '../../reactiveQueries/sql.js'
-import { makeTodoMvc, parseTodos } from './fixture.js'
+import { makeTodoMvc, parseTodos } from '../__tests__/react/fixture.js'
+import { querySQL } from '../reactiveQueries/sql.js'
+import * as LiveStoreReact from './index.js'
 
 describe('useQuery', () => {
   it('simple', async () => {
     let renderCount = 0
 
-    const { wrapper, store, mutations } = await makeTodoMvc()
+    const { wrapper, store, cud } = await makeTodoMvc()
 
     const allTodos$ = querySQL(`select * from todos`, { map: parseTodos })
 
@@ -26,7 +26,7 @@ describe('useQuery', () => {
     expect(result.current.length).toBe(0)
     expect(renderCount).toBe(1)
 
-    act(() => store.applyEvents([mutations.todos.insert({ id: 't1', text: 'buy milk', completed: false })]))
+    act(() => store.mutate(cud.todos.insert({ id: 't1', text: 'buy milk', completed: false })))
 
     expect(result.current.length).toBe(1)
     expect(result.current[0]!.text).toBe('buy milk')
@@ -36,15 +36,15 @@ describe('useQuery', () => {
   it('same `useQuery` hook invoked with different queries', async () => {
     let renderCount = 0
 
-    const { wrapper, store, mutations } = await makeTodoMvc()
+    const { wrapper, store, cud } = await makeTodoMvc()
 
     const todo1$ = querySQL(`select * from todos where id = 't1'`, { label: 'libraryTracksView1', map: parseTodos })
     const todo2$ = querySQL(`select * from todos where id = 't2'`, { label: 'libraryTracksView2', map: parseTodos })
 
-    store.applyEvents([
-      mutations.todos.insert({ id: 't1', text: 'buy milk', completed: false }),
-      mutations.todos.insert({ id: 't2', text: 'buy eggs', completed: false }),
-    ])
+    store.mutate(
+      cud.todos.insert({ id: 't1', text: 'buy milk', completed: false }),
+      cud.todos.insert({ id: 't2', text: 'buy eggs', completed: false }),
+    )
 
     const { result, rerender } = renderHook(
       (todoId: string) => {
@@ -60,7 +60,7 @@ describe('useQuery', () => {
     expect(result.current).toBe('buy milk')
     expect(renderCount).toBe(1)
 
-    act(() => store.applyEvents([mutations.todos.update({ where: { id: 't1' }, values: { text: 'buy soy milk' } })]))
+    act(() => store.mutate(cud.todos.update({ where: { id: 't1' }, values: { text: 'buy soy milk' } })))
 
     expect(result.current).toBe('buy soy milk')
     expect(renderCount).toBe(2)

package/src/{__tests__/react → react}/useRow.test.tsx

@@ -2,10 +2,11 @@ import { act, render, renderHook } from '@testing-library/react'
 import React from 'react'
 import { describe, expect, it } from 'vitest'
 
-import * as LiveStore from '../../index.js'
-import * as LiveStoreReact from '../../react/index.js'
-import type { Todo } from './fixture.js'
-import { makeTodoMvc, todos } from './fixture.js'
+import type { Todo } from '../__tests__/react/fixture.js'
+import { makeTodoMvc, todos } from '../__tests__/react/fixture.js'
+import * as LiveStore from '../index.js'
+import { mutationForQueryInfo } from '../query-info.js'
+import * as LiveStoreReact from './index.js'
 
 describe('useRow', () => {
   it('should update the data based on component key', async () => {
@@ -27,9 +28,7 @@ describe('useRow', () => {
     expect(result.current.state.username).toBe('')
     expect(renderCount).toBe(1)
 
-    act(() => {
-      void store.execute(LiveStore.sql`INSERT INTO UserInfo (id, username) VALUES ('u2', 'username_u2');`)
-    })
+    act(() => store.execute(LiveStore.sql`INSERT INTO UserInfo (id, username) VALUES ('u2', 'username_u2')`))
 
     rerender('u2')
 
@@ -85,9 +84,7 @@ describe('useRow', () => {
 
     act(() => result.current.setState.username('username_u1_hello'))
 
-    act(() => {
-      void store.execute(LiveStore.sql`UPDATE UserInfo SET username = 'username_u1_hello' WHERE id = 'u1';`)
-    })
+    act(() => store.execute(LiveStore.sql`UPDATE UserInfo SET username = 'username_u1_hello' WHERE id = 'u1';`))
 
     expect(result.current.state.id).toBe('u1')
     expect(result.current.state.username).toBe('username_u1_hello')
@@ -149,10 +146,11 @@ describe('useRow', () => {
     expect(appRouterRenderCount).toBe(1)
 
     act(() =>
-      store.applyEvent('livestore.RawSql', {
-        sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);`,
-        writeTables: ['todos'],
-      }),
+      store.mutate(
+        LiveStore.rawSqlMutation({
+          sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)`,
+        }),
+      ),
     )
 
     expect(appRouterRenderCount).toBe(1)
@@ -168,31 +166,15 @@ describe('useRow', () => {
     expect(renderResult.getByRole('current-id').innerHTML).toMatchInlineSnapshot('"Current Task Id: t1"')
 
     act(() =>
-      store.applyEvents([
-        {
-          eventType: 'livestore.RawSql',
-          args: {
-            sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t2', 'buy eggs', 0);`,
-            writeTables: ['todos'],
-          },
-        },
-        {
-          eventType: 'livestore.UpdateComponentState',
-          args: {
-            id: 'singleton',
-            columnNames: ['currentTaskId'],
-            tableName: AppRouterSchema.sqliteDef.name,
-            bindValues: { currentTaskId: 't2' },
-          },
-        },
-        {
-          eventType: 'livestore.RawSql',
-          args: {
-            sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t3', 'buy bread', 0);`,
-            writeTables: ['todos'],
-          },
-        },
-      ]),
+      store.mutate(
+        LiveStore.rawSqlMutation({
+          sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t2', 'buy eggs', 0)`,
+        }),
+        mutationForQueryInfo({ _tag: 'Col', table: AppRouterSchema, column: 'currentTaskId', id: 'singleton' }, 't2'),
+        LiveStore.rawSqlMutation({
+          sql: LiveStore.sql`INSERT INTO todos (id, text, completed) VALUES ('t3', 'buy bread', 0)`,
+        }),
+      ),
     )
 
     expect(appRouterRenderCount).toBe(3)

package/src/react/useRow.ts

@@ -5,7 +5,7 @@ import React from 'react'
 
 import type { DbGraph, LiveQuery } from '../index.js'
 import type { QueryInfo } from '../query-info.js'
-import { storeEventForQueryInfo } from '../query-info.js'
+import { mutationForQueryInfo } from '../query-info.js'
 import type { RowResult } from '../row-query.js'
 import { rowQuery } from '../row-query.js'
 import { type DefaultSqliteTableDef, type TableDef, tableIsSingleton, type TableOptions } from '../schema/table-def.js'
@@ -117,7 +117,7 @@ export const useRow: {
         const newValue = typeof newValueOrFn === 'function' ? newValueOrFn(query$Ref.current) : newValueOrFn
         if (query$Ref.current === newValue) return
 
-        store.applyEvents([storeEventForQueryInfo(query$.queryInfo!, { value: newValue })])
+        store.mutate(mutationForQueryInfo(query$.queryInfo!, { value: newValue }))
       }
     } else {
       const setState = // TODO: do we have a better type for the values that can go in SQLite?
@@ -130,7 +130,7 @@ export const useRow: {
           // @ts-expect-error TODO fix typing
           if (query$Ref.current[columnName] === newValue) return
 
-          store.applyEvents([storeEventForQueryInfo(query$.queryInfo!, { [columnName]: newValue })])
+          store.mutate(mutationForQueryInfo(query$.queryInfo!, { [columnName]: newValue }))
         })
 
       setState.setMany = (columnValuesOrFn: Partial<TComponentState>) => {
@@ -147,7 +147,7 @@ export const useRow: {
           return
         }
 
-        store.applyEvents([storeEventForQueryInfo(query$.queryInfo!, columnValues)])
+        store.mutate(mutationForQueryInfo(query$.queryInfo!, columnValues))
       }
 
       return setState as any

package/src/{__tests__/reactive.test.ts → reactive.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import { ReactiveGraph } from '../reactive.js'
+import { ReactiveGraph } from './reactive.js'
 
 describe('a trivial graph', () => {
   const makeGraph = () => {

package/src/reactive.ts

@@ -24,7 +24,7 @@
 /* eslint-disable prefer-arrow/prefer-arrow-functions */
 
 import type { PrettifyFlat } from '@livestore/utils'
-import { pick, shouldNeverHappen } from '@livestore/utils'
+import { shouldNeverHappen } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
 import { isEqual } from 'lodash-es'
 
@@ -94,7 +94,7 @@ export type DebugThunkInfo<T extends string = string> = {
 }
 
 export type DebugRefreshReasonBase =
-  /** Usually in response to some `applyEvent`/`applyEvents` with `skipRefresh: true` */
+  /** Usually in response to some `mutate` calls with `skipRefresh: true` */
   | {
       _tag: 'runDeferredEffects'
       originalRefreshReasons?: ReadonlyArray<DebugRefreshReasonBase>
@@ -135,7 +135,7 @@ const unknownRefreshReason = () => {
 
 export type SerializedAtom = Readonly<
   PrettifyFlat<
-    Pick<Atom<unknown, unknown, any>, '_tag' | 'id' | 'label' | 'meta'> & {
+    Pick<Atom<unknown, unknown, any>, '_tag' | 'id' | 'label' | 'meta' | 'isDirty'> & {
       sub: ReadonlyArray<string>
       super: ReadonlyArray<string>
     }
@@ -162,17 +162,6 @@ const uniqueNodeId = () => `node-${++nodeIdCounter}`
 let refreshInfoIdCounter = 0
 const uniqueRefreshInfoId = () => `refresh-info-${++refreshInfoIdCounter}`
 
-const serializeAtom = (atom: Atom<any, unknown, any>): SerializedAtom => ({
-  ...pick(atom, ['_tag', 'id', 'label', 'meta', 'isDirty']),
-  sub: Array.from(atom.sub).map((a) => a.id),
-  super: Array.from(atom.super).map((a) => a.id),
-})
-
-const serializeEffect = (effect: Effect): SerializedEffect => ({
-  ...pick(effect, ['_tag', 'id', 'label']),
-  sub: Array.from(effect.sub).map((a) => a.id),
-})
-
 let globalGraphIdCounter = 0
 const uniqueGraphId = () => `graph-${++globalGraphIdCounter}`
 
@@ -515,11 +504,25 @@ export class ReactiveGraph<
     subComp.super.delete(superComp)
   }
 
-  getSnapshot = (): ReactiveGraphSnapshot => ({
-    atoms: Array.from(this.atoms).map(serializeAtom),
-    effects: Array.from(this.effects).map(serializeEffect),
-    deferredEffects: Array.from(this.deferredEffects.keys()).map((_) => _.id),
-  })
+  // NOTE This function is performance-optimized (i.e. not using `Array.from`)
+  getSnapshot = (): ReactiveGraphSnapshot => {
+    const atoms: SerializedAtom[] = []
+    for (const atom of this.atoms) {
+      atoms.push(serializeAtom(atom))
+    }
+
+    const effects: SerializedEffect[] = []
+    for (const effect of this.effects) {
+      effects.push(serializeEffect(effect))
+    }
+
+    const deferredEffects: string[] = []
+    for (const [effect] of this.deferredEffects) {
+      deferredEffects.push(effect.id)
+    }
+
+    return { atoms, effects, deferredEffects }
+  }
 
   subscribeToRefresh = (cb: () => void) => {
     this.refreshCallbacks.add(cb)
@@ -561,3 +564,41 @@ const markSuperCompDirtyRec = <T>(atom: Atom<T, unknown, any>, effectsToRefresh:
 export const throwContextNotSetError = (graph: ReactiveGraph<any, any, any>): never => {
   throw new Error(`LiveStore Error: \`context\` not set on ReactiveGraph (${graph.id})`)
 }
+
+// NOTE This function is performance-optimized (i.e. not using `pick` and `Array.from`)
+const serializeAtom = (atom: Atom<any, unknown, any>): SerializedAtom => {
+  const sub: string[] = []
+  for (const a of atom.sub) {
+    sub.push(a.id)
+  }
+
+  const super_: string[] = []
+  for (const a of atom.super) {
+    super_.push(a.id)
+  }
+
+  return {
+    _tag: atom._tag,
+    id: atom.id,
+    label: atom.label,
+    meta: atom.meta,
+    isDirty: atom.isDirty,
+    sub,
+    super: super_,
+  }
+}
+
+// NOTE This function is performance-optimized (i.e. not using `pick` and `Array.from`)
+const serializeEffect = (effect: Effect): SerializedEffect => {
+  const sub: string[] = []
+  for (const a of effect.sub) {
+    sub.push(a.id)
+  }
+
+  return {
+    _tag: effect._tag,
+    id: effect.id,
+    label: effect.label,
+    sub,
+  }
+}