@livestore/common 0.3.0-dev.28 → 0.3.0-dev.29

package/src/derived-mutations.test.ts

@@ -1,101 +0,0 @@
-import { describe, expect, test } from 'vitest'
-
-import { appConfig, todos } from './__tests__/fixture.js'
-import type * as MutationEvent from './schema/MutationEvent.js'
-
-describe('derived mutations', () => {
-  test('todos', () => {
-    expect(patchId(todos.insert({ id: 't1', completed: true, text: 'Task 1' }))).toMatchInlineSnapshot(`
-      {
-        "args": {
-          "completed": true,
-          "id": "t1",
-          "text": "Task 1",
-        },
-        "id": "00000000-0000-0000-0000-000000000000",
-        "mutation": "_Derived_Create_todos",
-      }
-    `)
-
-    expect(patchId(todos.update({ where: { id: 't1' }, values: { text: 'Task 1 - fixed' } }))).toMatchInlineSnapshot(`
-      {
-        "args": {
-          "values": {
-            "text": "Task 1 - fixed",
-          },
-          "where": {
-            "id": "t1",
-          },
-        },
-        "id": "00000000-0000-0000-0000-000000000000",
-        "mutation": "_Derived_Update_todos",
-      }
-    `)
-
-    expect(patchId(todos.delete({ where: { id: 't1' } }))).toMatchInlineSnapshot(`
-      {
-        "args": {
-          "where": {
-            "id": "t1",
-          },
-        },
-        "id": "00000000-0000-0000-0000-000000000000",
-        "mutation": "_Derived_Delete_todos",
-      }
-    `)
-  })
-
-  test('app_config', () => {
-    expect(patchId(appConfig.insert())).toMatchInlineSnapshot(`
-      {
-        "args": {
-          "id": "singleton",
-          "value": {
-            "value": undefined,
-          },
-        },
-        "id": "00000000-0000-0000-0000-000000000000",
-        "mutation": "_Derived_Create_app_config",
-      }
-    `)
-
-    expect(patchId(appConfig.insert({ fontSize: 12, theme: 'dark' }))).toMatchInlineSnapshot(`
-      {
-        "args": {
-          "id": "singleton",
-          "value": {
-            "value": {
-              "fontSize": 12,
-              "theme": "dark",
-            },
-          },
-        },
-        "id": "00000000-0000-0000-0000-000000000000",
-        "mutation": "_Derived_Create_app_config",
-      }
-    `)
-
-    expect(patchId(appConfig.update({ fontSize: 13 }))).toMatchInlineSnapshot(`
-      {
-        "args": {
-          "values": {
-            "value": {
-              "fontSize": 13,
-            },
-          },
-          "where": {
-            "id": "singleton",
-          },
-        },
-        "id": "00000000-0000-0000-0000-000000000000",
-        "mutation": "_Derived_Update_app_config",
-      }
-    `)
-  })
-})
-
-const patchId = (muationEvent: MutationEvent.PartialAnyDecoded) => {
-  // TODO use new id paradigm
-  const id = `00000000-0000-0000-0000-000000000000`
-  return { ...muationEvent, id }
-}

package/src/derived-mutations.ts

@@ -1,170 +0,0 @@
-import type { GetValForKey } from '@livestore/utils'
-import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
-
-import type { SqliteDsl } from './schema/db-schema/mod.js'
-import type * as MutationEvent from './schema/MutationEvent.js'
-import { defineMutation } from './schema/mutations.js'
-import { getDefaultValuesDecoded } from './schema/schema-helpers.js'
-import type * as DbSchema from './schema/table-def.js'
-import { deleteRows, insertRow, updateRows } from './sql-queries/sql-queries.js'
-
-export const makeDerivedMutationDefsForTable = <
-  TTableDef extends DbSchema.TableDefBase<
-    DbSchema.DefaultSqliteTableDefConstrained,
-    DbSchema.TableOptions & { deriveMutations: { enabled: true } }
-  >,
->(
-  table: TTableDef,
-) => ({
-  insert: deriveCreateMutationDef(table),
-  update: deriveUpdateMutationDef(table),
-  delete: deriveDeleteMutationDef(table),
-})
-
-export const deriveCreateMutationDef = <
-  TTableDef extends DbSchema.TableDefBase<
-    DbSchema.DefaultSqliteTableDefConstrained,
-    DbSchema.TableOptions & { deriveMutations: { enabled: true } }
-  >,
->(
-  table: TTableDef,
-) => {
-  const tableName = table.sqliteDef.name
-
-  const [optionalFields, requiredColumns] = ReadonlyRecord.partition(
-    (table.sqliteDef as DbSchema.DefaultSqliteTableDef).columns,
-    (col) => col.nullable === false && col.default._tag === 'None',
-  )
-
-  const insertSchema = Schema.Struct(ReadonlyRecord.map(requiredColumns, (col) => col.schema))
-    .pipe(Schema.extend(Schema.partial(Schema.Struct(ReadonlyRecord.map(optionalFields, (col) => col.schema)))))
-    .annotations({ title: `${tableName}:Insert` })
-
-  return defineMutation(
-    `_Derived_Create_${tableName}`,
-    insertSchema,
-    ({ id, ...explicitDefaultValues }) => {
-      const defaultValues = getDefaultValuesDecoded(table, explicitDefaultValues)
-
-      const [sql, bindValues] = insertRow({
-        tableName: table.sqliteDef.name,
-        columns: table.sqliteDef.columns,
-        values: { ...defaultValues, id },
-      })
-
-      return { sql, bindValues, writeTables: new Set([tableName]) }
-    },
-    { clientOnly: table.options.deriveMutations.clientOnly },
-  )
-}
-
-export const deriveUpdateMutationDef = <
-  TTableDef extends DbSchema.TableDefBase<
-    DbSchema.DefaultSqliteTableDefConstrained,
-    DbSchema.TableOptions & { deriveMutations: { enabled: true } }
-  >,
->(
-  table: TTableDef,
-) => {
-  const tableName = table.sqliteDef.name
-
-  return defineMutation(
-    `_Derived_Update_${tableName}`,
-    Schema.Struct({
-      where: Schema.partial(table.schema),
-      values: Schema.partial(table.schema),
-    }).annotations({ title: `${tableName}:Update` }),
-    ({ where, values }) => {
-      const [sql, bindValues] = updateRows({
-        tableName: table.sqliteDef.name,
-        columns: table.sqliteDef.columns,
-        where,
-        updateValues: values,
-      })
-
-      return { sql, bindValues, writeTables: new Set([tableName]) }
-    },
-    { clientOnly: table.options.deriveMutations.clientOnly },
-  )
-}
-
-export const deriveDeleteMutationDef = <
-  TTableDef extends DbSchema.TableDefBase<
-    DbSchema.DefaultSqliteTableDefConstrained,
-    DbSchema.TableOptions & { deriveMutations: { enabled: true } }
-  >,
->(
-  table: TTableDef,
-) => {
-  const tableName = table.sqliteDef.name
-
-  return defineMutation(
-    `_Derived_Delete_${tableName}`,
-    Schema.Struct({
-      where: Schema.partial(table.schema),
-    }),
-    ({ where }) => {
-      const [sql, bindValues] = deleteRows({
-        tableName: table.sqliteDef.name,
-        columns: table.sqliteDef.columns,
-        where,
-      })
-
-      return { sql, bindValues, writeTables: new Set([tableName]) }
-    },
-    { clientOnly: table.options.deriveMutations.clientOnly },
-  )
-}
-
-/**
- * Convenience helper functions on top of the derived mutation definitions.
- */
-export type DerivedMutationHelperFns<
-  TColumns extends SqliteDsl.ConstraintColumns,
-  TOptions extends DbSchema.TableOptions,
-> = {
-  insert: DerivedMutationHelperFns.InsertMutationFn<TColumns, TOptions>
-  update: DerivedMutationHelperFns.UpdateMutationFn<TColumns, TOptions>
-  delete: DerivedMutationHelperFns.DeleteMutationFn<TColumns, TOptions>
-  // TODO also consider adding upsert and deep json mutations (like lenses)
-}
-
-export namespace DerivedMutationHelperFns {
-  export type InsertMutationFn<
-    TColumns extends SqliteDsl.ConstraintColumns,
-    TOptions extends DbSchema.TableOptions,
-  > = SqliteDsl.AnyIfConstained<
-    TColumns,
-    UseShortcut<TOptions> extends true
-      ? (
-          values?: GetValForKey<SqliteDsl.FromColumns.InsertRowDecoded<TColumns>, 'value'>,
-        ) => MutationEvent.PartialAnyDecoded
-      : (values: SqliteDsl.FromColumns.InsertRowDecoded<TColumns>) => MutationEvent.PartialAnyDecoded
-  >
-
-  export type UpdateMutationFn<
-    TColumns extends SqliteDsl.ConstraintColumns,
-    TOptions extends DbSchema.TableOptions,
-  > = SqliteDsl.AnyIfConstained<
-    TColumns,
-    UseShortcut<TOptions> extends true
-      ? (
-          values: Partial<GetValForKey<SqliteDsl.FromColumns.RowDecoded<TColumns>, 'value'>>,
-        ) => MutationEvent.PartialAnyDecoded
-      : (args: {
-          where: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>>
-          values: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>>
-        }) => MutationEvent.PartialAnyDecoded
-  >
-
-  export type DeleteMutationFn<
-    TColumns extends SqliteDsl.ConstraintColumns,
-    _TOptions extends DbSchema.TableOptions,
-  > = (args: { where: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>> }) => MutationEvent.PartialAnyDecoded
-
-  type UseShortcut<TOptions extends DbSchema.TableOptions> = TOptions['isSingleColumn'] extends true
-    ? TOptions['isSingleton'] extends true
-      ? true
-      : false
-    : false
-}

package/src/init-singleton-tables.ts

@@ -1,24 +0,0 @@
-import type { SqliteDb } from './adapter-types.js'
-import type { LiveStoreSchema } from './schema/mod.js'
-import { getDefaultValuesEncoded } from './schema/schema-helpers.js'
-import { prepareBindValues, sql } from './util.js'
-
-export const initializeSingletonTables = (schema: LiveStoreSchema, db: SqliteDb) => {
-  for (const [, tableDef] of schema.tables) {
-    if (tableDef.options.isSingleton) {
-      const defaultValues = getDefaultValuesEncoded(tableDef, undefined)
-
-      const defaultColumnNames = [...Object.keys(defaultValues), 'id']
-      const columnValues = defaultColumnNames.map((name) => `$${name}`).join(', ')
-
-      const tableName = tableDef.sqliteDef.name
-      const insertQuery = sql`insert into ${tableName} (${defaultColumnNames.join(
-        ', ',
-      )}) select ${columnValues} where not exists(select 1 from ${tableName} where id = 'singleton')`
-
-      const bindValues = prepareBindValues({ ...defaultValues, id: 'singleton' }, insertQuery)
-
-      db.execute(insertQuery, bindValues)
-    }
-  }
-}

package/src/leader-thread/mutationlog.ts

@@ -1,202 +0,0 @@
-import { LS_DEV, shouldNeverHappen } from '@livestore/utils'
-import { Effect, Option, Schema } from '@livestore/utils/effect'
-
-import type { SqliteDb } from '../adapter-types.js'
-import * as EventId from '../schema/EventId.js'
-import * as MutationEvent from '../schema/MutationEvent.js'
-import {
-  MUTATION_LOG_META_TABLE,
-  mutationLogMetaTable,
-  sessionChangesetMetaTable,
-  SYNC_STATUS_TABLE,
-  syncStatusTable,
-} from '../schema/system-tables.js'
-import { migrateTable } from '../schema-management/migrations.js'
-import { insertRow, updateRows } from '../sql-queries/sql-queries.js'
-import type { PreparedBindValues } from '../util.js'
-import { prepareBindValues, sql } from '../util.js'
-import { execSql } from './connection.js'
-import type { InitialSyncInfo } from './types.js'
-import { LeaderThreadCtx } from './types.js'
-
-export const initMutationLogDb = (dbMutationLog: SqliteDb) =>
-  Effect.gen(function* () {
-    yield* migrateTable({
-      db: dbMutationLog,
-      behaviour: 'create-if-not-exists',
-      tableAst: mutationLogMetaTable.sqliteDef.ast,
-      skipMetaTable: true,
-    })
-
-    yield* migrateTable({
-      db: dbMutationLog,
-      behaviour: 'create-if-not-exists',
-      tableAst: syncStatusTable.sqliteDef.ast,
-      skipMetaTable: true,
-    })
-
-    // Create sync status row if it doesn't exist
-    yield* execSql(
-      dbMutationLog,
-      sql`INSERT INTO ${SYNC_STATUS_TABLE} (head)
-          SELECT ${EventId.ROOT.global}
-          WHERE NOT EXISTS (SELECT 1 FROM ${SYNC_STATUS_TABLE})`,
-      {},
-    )
-  })
-
-/** Exclusive of the "since event" */
-export const getMutationEventsSince = (
-  since: EventId.EventId,
-): Effect.Effect<ReadonlyArray<MutationEvent.EncodedWithMeta>, never, LeaderThreadCtx> =>
-  Effect.gen(function* () {
-    const { dbMutationLog, dbReadModel } = yield* LeaderThreadCtx
-
-    const query = mutationLogMetaTable.query.where('idGlobal', '>=', since.global).asSql()
-    const pendingMutationEventsRaw = dbMutationLog.select(query.query, prepareBindValues(query.bindValues, query.query))
-    const pendingMutationEvents = Schema.decodeUnknownSync(mutationLogMetaTable.schema.pipe(Schema.Array))(
-      pendingMutationEventsRaw,
-    )
-
-    const sessionChangesetRows = sessionChangesetMetaTable.query.where('idGlobal', '>=', since.global).asSql()
-    const sessionChangesetRowsRaw = dbReadModel.select(
-      sessionChangesetRows.query,
-      prepareBindValues(sessionChangesetRows.bindValues, sessionChangesetRows.query),
-    )
-    const sessionChangesetRowsDecoded = Schema.decodeUnknownSync(sessionChangesetMetaTable.schema.pipe(Schema.Array))(
-      sessionChangesetRowsRaw,
-    )
-
-    return pendingMutationEvents
-      .map((mutationLogEvent) => {
-        const sessionChangeset = sessionChangesetRowsDecoded.find(
-          (readModelEvent) =>
-            readModelEvent.idGlobal === mutationLogEvent.idGlobal &&
-            readModelEvent.idClient === mutationLogEvent.idClient,
-        )
-        return MutationEvent.EncodedWithMeta.make({
-          mutation: mutationLogEvent.mutation,
-          args: mutationLogEvent.argsJson,
-          id: { global: mutationLogEvent.idGlobal, client: mutationLogEvent.idClient },
-          parentId: { global: mutationLogEvent.parentIdGlobal, client: mutationLogEvent.parentIdClient },
-          clientId: mutationLogEvent.clientId,
-          sessionId: mutationLogEvent.sessionId,
-          meta: {
-            sessionChangeset:
-              sessionChangeset && sessionChangeset.changeset !== null
-                ? {
-                    _tag: 'sessionChangeset' as const,
-                    data: sessionChangeset.changeset,
-                    debug: sessionChangeset.debug,
-                  }
-                : { _tag: 'unset' as const },
-            syncMetadata: mutationLogEvent.syncMetadataJson,
-          },
-        })
-      })
-      .filter((_) => EventId.compare(_.id, since) > 0)
-      .sort((a, b) => EventId.compare(a.id, b.id))
-  })
-
-export const getClientHeadFromDb = (dbMutationLog: SqliteDb): EventId.EventId => {
-  const res = dbMutationLog.select<{ idGlobal: EventId.GlobalEventId; idClient: EventId.ClientEventId }>(
-    sql`select idGlobal, idClient from ${MUTATION_LOG_META_TABLE} order by idGlobal DESC, idClient DESC limit 1`,
-  )[0]
-
-  return res ? { global: res.idGlobal, client: res.idClient } : EventId.ROOT
-}
-
-export const getBackendHeadFromDb = (dbMutationLog: SqliteDb): EventId.GlobalEventId =>
-  dbMutationLog.select<{ head: EventId.GlobalEventId }>(sql`select head from ${SYNC_STATUS_TABLE}`)[0]?.head ??
-  EventId.ROOT.global
-
-// TODO use prepared statements
-export const updateBackendHead = (dbMutationLog: SqliteDb, head: EventId.EventId) =>
-  dbMutationLog.execute(sql`UPDATE ${SYNC_STATUS_TABLE} SET head = ${head.global}`)
-
-export const insertIntoMutationLog = (
-  mutationEventEncoded: MutationEvent.EncodedWithMeta,
-  dbMutationLog: SqliteDb,
-  mutationDefSchemaHash: number,
-  clientId: string,
-  sessionId: string,
-) =>
-  Effect.gen(function* () {
-    // Check history consistency during LS_DEV
-    if (LS_DEV && mutationEventEncoded.parentId.global !== EventId.ROOT.global) {
-      const parentMutationExists =
-        dbMutationLog.select<{ count: number }>(
-          `SELECT COUNT(*) as count FROM ${MUTATION_LOG_META_TABLE} WHERE idGlobal = ? AND idClient = ?`,
-          [mutationEventEncoded.parentId.global, mutationEventEncoded.parentId.client] as any as PreparedBindValues,
-        )[0]!.count === 1
-
-      if (parentMutationExists === false) {
-        shouldNeverHappen(
-          `Parent mutation ${mutationEventEncoded.parentId.global},${mutationEventEncoded.parentId.client} does not exist`,
-        )
-      }
-    }
-
-    // TODO use prepared statements
-    yield* execSql(
-      dbMutationLog,
-      ...insertRow({
-        tableName: MUTATION_LOG_META_TABLE,
-        columns: mutationLogMetaTable.sqliteDef.columns,
-        values: {
-          idGlobal: mutationEventEncoded.id.global,
-          idClient: mutationEventEncoded.id.client,
-          parentIdGlobal: mutationEventEncoded.parentId.global,
-          parentIdClient: mutationEventEncoded.parentId.client,
-          mutation: mutationEventEncoded.mutation,
-          argsJson: mutationEventEncoded.args ?? {},
-          clientId,
-          sessionId,
-          schemaHash: mutationDefSchemaHash,
-          syncMetadataJson: mutationEventEncoded.meta.syncMetadata,
-        },
-      }),
-    )
-  })
-
-export const updateSyncMetadata = (items: ReadonlyArray<MutationEvent.EncodedWithMeta>) =>
-  Effect.gen(function* () {
-    const { dbMutationLog } = yield* LeaderThreadCtx
-
-    // TODO try to do this in a single query
-    for (let i = 0; i < items.length; i++) {
-      const mutationEvent = items[i]!
-
-      yield* execSql(
-        dbMutationLog,
-        ...updateRows({
-          tableName: MUTATION_LOG_META_TABLE,
-          columns: mutationLogMetaTable.sqliteDef.columns,
-          where: { idGlobal: mutationEvent.id.global, idClient: mutationEvent.id.client },
-          updateValues: { syncMetadataJson: mutationEvent.meta.syncMetadata },
-        }),
-      )
-    }
-  })
-
-export const getSyncBackendCursorInfo = (remoteHead: EventId.GlobalEventId) =>
-  Effect.gen(function* () {
-    const { dbMutationLog } = yield* LeaderThreadCtx
-
-    if (remoteHead === EventId.ROOT.global) return Option.none()
-
-    const MutationlogQuerySchema = Schema.Struct({
-      syncMetadataJson: Schema.parseJson(Schema.Option(Schema.JsonValue)),
-    }).pipe(Schema.pluck('syncMetadataJson'), Schema.Array, Schema.head)
-
-    const syncMetadataOption = yield* Effect.sync(() =>
-      dbMutationLog.select<{ syncMetadataJson: string }>(
-        sql`SELECT syncMetadataJson FROM ${MUTATION_LOG_META_TABLE} WHERE idGlobal = ${remoteHead} ORDER BY idClient ASC LIMIT 1`,
-      ),
-    ).pipe(Effect.andThen(Schema.decode(MutationlogQuerySchema)), Effect.map(Option.flatten), Effect.orDie)
-
-    return Option.some({
-      cursor: { global: remoteHead, client: EventId.clientDefault },
-      metadata: syncMetadataOption,
-    }) satisfies InitialSyncInfo
-  }).pipe(Effect.withSpan('@livestore/common:mutationlog:getSyncBackendCursorInfo', { attributes: { remoteHead } }))

package/src/mutation.ts

@@ -1,108 +0,0 @@
-import { Schema } from '@livestore/utils/effect'
-
-import { SessionIdSymbol } from './adapter-types.js'
-import type { QueryBuilder } from './query-builder/api.js'
-import { isQueryBuilder } from './query-builder/api.js'
-import type * as MutationEvent from './schema/MutationEvent.js'
-import type { MutationDef, MutationHandlerResult } from './schema/mutations.js'
-import type { BindValues } from './sql-queries/sql-queries.js'
-import type { PreparedBindValues } from './util.js'
-import { prepareBindValues } from './util.js'
-
-export const getExecArgsFromMutation = ({
-  mutationDef,
-  mutationEvent,
-}: {
-  mutationDef: MutationDef.Any
-  /** Both encoded and decoded mutation events are supported to reduce the number of times we need to decode/encode */
-  mutationEvent:
-    | {
-        decoded: MutationEvent.AnyDecoded | MutationEvent.PartialAnyDecoded
-        encoded: undefined
-      }
-    | {
-        decoded: undefined
-        encoded: MutationEvent.AnyEncoded | MutationEvent.PartialAnyEncoded
-      }
-}): ReadonlyArray<{
-  statementSql: string
-  bindValues: PreparedBindValues
-  writeTables: ReadonlySet<string> | undefined
-}> => {
-  let statementRes: ReadonlyArray<
-    string | { sql: string; bindValues: Record<string, unknown>; writeTables?: ReadonlySet<string> }
-  >
-
-  switch (typeof mutationDef.sql) {
-    case 'function': {
-      const mutationArgsDecoded =
-        mutationEvent.decoded?.args ?? Schema.decodeUnknownSync(mutationDef.schema)(mutationEvent.encoded!.args)
-
-      const res = mutationDef.sql(mutationArgsDecoded, {
-        clientOnly: mutationDef.options.clientOnly,
-        // TODO properly implement this
-        currentFacts: new Map(),
-      })
-
-      statementRes = (Array.isArray(res) ? res : [res]).map((_: QueryBuilder.Any | MutationHandlerResult) => {
-        if (isQueryBuilder(_)) {
-          const { query, bindValues } = _.asSql()
-          return { sql: query, bindValues: bindValues as BindValues }
-        }
-
-        return _
-      })
-
-      break
-    }
-    case 'string': {
-      statementRes = [mutationDef.sql]
-      break
-    }
-    default: {
-      statementRes = mutationDef.sql
-      break
-    }
-  }
-
-  return statementRes.map((statementRes) => {
-    const statementSql = typeof statementRes === 'string' ? statementRes : statementRes.sql
-
-    const mutationArgsEncoded =
-      mutationEvent.encoded?.args ?? Schema.encodeUnknownSync(mutationDef.schema)(mutationEvent.decoded!.args)
-    const bindValues = typeof statementRes === 'string' ? mutationArgsEncoded : statementRes.bindValues
-
-    const writeTables = typeof statementRes === 'string' ? undefined : statementRes.writeTables
-
-    return { statementSql, bindValues: prepareBindValues(bindValues ?? {}, statementSql), writeTables }
-  })
-}
-
-// NOTE we should explore whether there is a more elegant solution
-// e.g. by leveraging the schema to replace the sessionIdSymbol
-export const replaceSessionIdSymbol = (
-  bindValues: Record<string, unknown> | ReadonlyArray<unknown>,
-  sessionId: string,
-) => {
-  deepReplaceValue(bindValues, SessionIdSymbol, sessionId)
-}
-
-const deepReplaceValue = <S, R>(input: any, searchValue: S, replaceValue: R): void => {
-  if (Array.isArray(input)) {
-    for (const i in input) {
-      if (input[i] === searchValue) {
-        input[i] = replaceValue
-      } else {
-        deepReplaceValue(input[i], searchValue, replaceValue)
-      }
-    }
-  } else if (typeof input === 'object' && input !== null) {
-    for (const key in input) {
-      if (input[key] === searchValue) {
-        input[key] = replaceValue
-      } else {
-        deepReplaceValue(input[key], searchValue, replaceValue)
-      }
-    }
-  }
-}

package/src/query-info.ts

@@ -1,83 +0,0 @@
-import type { SessionIdSymbol } from './adapter-types.js'
-import type { DbSchema } from './schema/mod.js'
-
-/**
- * Semantic information about a query with supported cases being:
- * - a whole row
- * - a single column value
- * - a sub value in a JSON column
- *
- * This information is currently only used for derived mutations.
- */
-export type QueryInfo = QueryInfo.None | QueryInfo.Row | QueryInfo.Col | QueryInfo.ColJsonValue | QueryInfo.Write
-// export type QueryInfo<TTableDef extends DbSchema.TableDefBase = DbSchema.TableDefBase> =
-// | QueryInfo.None
-// | QueryInfo.Row<TTableDef>
-// | QueryInfo.ColJsonValue<TTableDef, GetJsonColumn<TTableDef>>
-// | QueryInfo.Col<TTableDef, keyof TTableDef['sqliteDef']['columns']>
-
-export namespace QueryInfo {
-  export type None = {
-    _tag: 'None'
-  }
-
-  export type Row = {
-    _tag: 'Row'
-    table: DbSchema.TableDefBase
-    id: string | SessionIdSymbol | number
-  }
-
-  export type Col = {
-    _tag: 'Col'
-    table: DbSchema.TableDefBase
-    id: string | SessionIdSymbol | number
-    column: string
-  }
-
-  export type ColJsonValue = {
-    _tag: 'ColJsonValue'
-    table: DbSchema.TableDefBase
-    id: string | SessionIdSymbol | number
-    column: string
-    /**
-     * example: `$.tabs[3].items[2]` (`$` referring to the column value)
-     */
-    jsonPath: string
-  }
-
-  // NOTE Not yet used but we might want to use this in order to avoid write queries in read-only situations
-  export type Write = {
-    _tag: 'Write'
-  }
-
-  // NOTE maybe we want to bring back type-params back like below
-  // export type Row<TTableDef extends DbSchema.TableDefBase> = {
-  //   _tag: 'Row'
-  //   table: TTableDef
-  //   id: string | SessionIdSymbol
-  // }
-
-  // export type Col<TTableDef extends DbSchema.TableDefBase, TColName extends keyof TTableDef['sqliteDef']['columns']> = {
-  //   _tag: 'Col'
-  //   table: TTableDef
-  //   id: string | SessionIdSymbol
-  //   column: TColName
-  // }
-
-  // export type ColJsonValue<TTableDef extends DbSchema.TableDefBase, TColName extends GetJsonColumn<TTableDef>> = {
-  //   _tag: 'ColJsonValue'
-  //   table: TTableDef
-  //   id: string | SessionIdSymbol
-  //   column: TColName
-  //   /**
-  //    * example: `$.tabs[3].items[2]` (`$` referring to the column value)
-  //    */
-  //   jsonPath: string
-  // }
-}
-
-// type GetJsonColumn<TTableDef extends DbSchema.TableDefBase> = keyof {
-//   [ColName in keyof TTableDef['sqliteDef']['columns'] as TTableDef['sqliteDef']['columns'][ColName]['columnType'] extends 'text'
-//     ? ColName
-//     : never]: {}
-// }