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

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]: {}
-// }

package/src/schema/mutations.ts

@@ -1,193 +0,0 @@
-import { Schema } from '@livestore/utils/effect'
-
-import type { QueryBuilder } from '../query-builder/mod.js'
-import type { BindValues } from '../sql-queries/sql-queries.js'
-
-export type MutationDefMap = {
-  map: Map<string | 'livestore.RawSql', MutationDef.Any>
-  wasProvided: boolean
-}
-export type MutationDefRecord = {
-  'livestore.RawSql': RawSqlMutation
-  [name: string]: MutationDef.Any
-}
-
-export type InternalMutationSchema<TRecord extends MutationDefRecord = MutationDefRecord> = {
-  _DefRecord: TRecord
-
-  map: Map<keyof TRecord, TRecord[keyof TRecord]>
-  schemaHashMap: Map<keyof TRecord, number>
-}
-
-export type MutationDefSqlResult<TTo> =
-  | SingleOrReadonlyArray<string>
-  | ((
-      args: TTo,
-      context: { currentFacts: MutationEventFacts; clientOnly: boolean },
-    ) => SingleOrReadonlyArray<
-      | string
-      | {
-          sql: string
-          /** Note args need to be manually encoded to `BindValues` when returning this argument */
-          bindValues: BindValues
-          writeTables?: ReadonlySet<string>
-        }
-      | QueryBuilder.Any
-    >)
-
-export type MutationHandlerResult = {
-  sql: string
-  bindValues: BindValues
-  writeTables?: ReadonlySet<string>
-}
-
-export type SingleOrReadonlyArray<T> = T | ReadonlyArray<T>
-
-export type MutationDef<TName extends string, TFrom, TTo> = {
-  name: TName
-  schema: Schema.Schema<TTo, TFrom>
-  sql: MutationDefSqlResult<NoInfer<TTo>>
-  options: {
-    /** Warning: This feature is not fully implemented yet */
-    historyId: string
-    /**
-     * When set to true, the mutation won't be synced across clients but
-     */
-    clientOnly: boolean
-    /** Warning: This feature is not fully implemented yet */
-    facts: FactsCallback<TTo> | undefined
-  }
-
-  /** Helper function to construct a partial mutation event */
-  (args: TTo): {
-    mutation: TName
-    args: TTo
-  }
-}
-
-export type FactsCallback<TTo> = (
-  args: TTo,
-  currentFacts: MutationEventFacts,
-) => {
-  modify: {
-    set: Iterable<MutationEventFactInput>
-    unset: Iterable<MutationEventFactInput>
-  }
-  require: Iterable<MutationEventFactInput>
-}
-
-export namespace MutationDef {
-  export type Any = MutationDef<string, any, any>
-}
-
-export type MutationEventKey = string
-export type MutationEventFact = string
-export type MutationEventFacts = ReadonlyMap<string, any>
-
-export type MutationEventFactsGroup = {
-  modifySet: MutationEventFacts
-  modifyUnset: MutationEventFacts
-
-  /**
-   * Events on independent "dependency" branches are commutative which can facilitate more prioritized syncing
-   */
-  depRequire: MutationEventFacts
-  depRead: MutationEventFacts
-}
-
-export type MutationEventFactsSnapshot = Map<string, any>
-
-export type MutationEventFactInput = string | readonly [string, any]
-
-export const defineFacts = <
-  TRecord extends Record<string, MutationEventFactInput | ((...args: any[]) => MutationEventFactInput)>,
->(
-  record: TRecord,
-): TRecord => record
-
-export type DefineMutationOptions<TTo> = {
-  // TODO actually implement this
-  onError?: (error: any) => void
-  historyId?: string
-  /** Warning: This feature is not fully implemented yet */
-  facts?: (
-    args: TTo,
-    currentFacts: MutationEventFacts,
-  ) => {
-    modify?: {
-      set?: Iterable<MutationEventFactInput>
-      unset?: Iterable<MutationEventFactInput>
-    }
-    /**
-     * Two purposes: constrain history and constrain compaction
-     */
-    require?: Iterable<MutationEventFactInput>
-  }
-  /**
-   * When set to true, the mutation won't be synced over the network
-   */
-  clientOnly?: boolean
-}
-
-// TODO possibly also allow for mutation event subsumption behaviour
-export const defineMutation = <TName extends string, TFrom, TTo>(
-  name: TName,
-  schema: Schema.Schema<TTo, TFrom>,
-  sql: MutationDefSqlResult<NoInfer<TTo>>,
-  options?: DefineMutationOptions<TTo>,
-): MutationDef<TName, TFrom, TTo> => {
-  const makePartialEvent = (args: TTo) => ({ mutation: name, args })
-
-  Object.defineProperty(makePartialEvent, 'name', { value: name })
-  Object.defineProperty(makePartialEvent, 'schema', { value: schema })
-  Object.defineProperty(makePartialEvent, 'sql', { value: sql })
-  Object.defineProperty(makePartialEvent, 'options', {
-    value: {
-      historyId: options?.historyId ?? 'main',
-      clientOnly: options?.clientOnly ?? false,
-      facts: options?.facts
-        ? (args, currentFacts) => {
-            const res = options.facts!(args, currentFacts)
-            return {
-              modify: {
-                set: res.modify?.set ? new Set(res.modify.set) : new Set(),
-                unset: res.modify?.unset ? new Set(res.modify.unset) : new Set(),
-              },
-              require: res.require ? new Set(res.require) : new Set(),
-            }
-          }
-        : undefined,
-    } satisfies MutationDef.Any['options'],
-  })
-
-  return makePartialEvent as MutationDef<TName, TFrom, TTo>
-}
-
-export const makeMutationDefRecord = <TInputRecord extends Record<string, MutationDef.Any>>(
-  inputRecord: TInputRecord,
-): {
-  [K in TInputRecord[keyof TInputRecord]['name']]: Extract<TInputRecord[keyof TInputRecord], { name: K }>
-} => {
-  const result: any = {}
-
-  for (const [name, def] of Object.entries(inputRecord)) {
-    result[name] = def
-  }
-
-  result['livestore.RawSql'] = rawSqlMutation
-
-  return result
-}
-
-export const rawSqlMutation = defineMutation(
-  'livestore.RawSql',
-  Schema.Struct({
-    sql: Schema.String,
-    bindValues: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
-    writeTables: Schema.optional(Schema.ReadonlySet(Schema.String)),
-  }),
-  ({ sql, bindValues, writeTables }) => ({ sql, bindValues: bindValues ?? {}, writeTables }),
-)
-
-export type RawSqlMutation = typeof rawSqlMutation
-export type RawSqlMutationEvent = ReturnType<typeof rawSqlMutation>