@livestore/common 0.3.0-dev.5 → 0.3.0-dev.50

package/src/rehydrate-from-mutationlog.ts

@@ -1,127 +0,0 @@
-import { isDevEnv, memoizeByRef, shouldNeverHappen } from '@livestore/utils'
-import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
-
-import { type MigrationOptionsFromMutationLog, type SynchronousDatabase, UnexpectedError } from './adapter-types.js'
-import { getExecArgsFromMutation } from './mutation.js'
-import type { LiveStoreSchema, MutationDef, MutationEvent, MutationLogMetaRow } from './schema/mod.js'
-import { EventId, MUTATION_LOG_META_TABLE } from './schema/mod.js'
-import type { PreparedBindValues } from './util.js'
-import { sql } from './util.js'
-
-export const rehydrateFromMutationLog = ({
-  logDb,
-  db,
-  schema,
-  migrationOptions,
-  onProgress,
-}: {
-  logDb: SynchronousDatabase
-  db: SynchronousDatabase
-  schema: LiveStoreSchema
-  migrationOptions: MigrationOptionsFromMutationLog
-  onProgress: (_: { done: number; total: number }) => Effect.Effect<void>
-}) =>
-  Effect.gen(function* () {
-    const mutationsCount = logDb.select<{ count: number }>(
-      `SELECT COUNT(*) AS count FROM ${MUTATION_LOG_META_TABLE}`,
-    )[0]!.count
-
-    const hashMutation = memoizeByRef((mutation: MutationDef.Any) => Schema.hash(mutation.schema))
-
-    const processMutation = (row: MutationLogMetaRow) =>
-      Effect.gen(function* () {
-        const mutationDef = schema.mutations.get(row.mutation) ?? shouldNeverHappen(`Unknown mutation ${row.mutation}`)
-
-        if (migrationOptions.excludeMutations?.has(row.mutation) === true) return
-
-        if (hashMutation(mutationDef) !== row.schemaHash) {
-          yield* Effect.logWarning(
-            `Schema hash mismatch for mutation ${row.mutation}. Trying to apply mutation anyway.`,
-          )
-        }
-
-        const argsDecoded = yield* Schema.decodeUnknown(Schema.parseJson(mutationDef.schema))(row.argsJson).pipe(
-          Effect.mapError((cause) =>
-            UnexpectedError.make({
-              cause,
-              note: `\
-There was an error during rehydrating from the mutation log while decoding
-the persisted mutation event args for mutation "${row.mutation}".
-This likely means the schema has changed in an incompatible way.
-`,
-            }),
-          ),
-        )
-
-        const mutationEventDecoded = {
-          id: { global: row.idGlobal, local: row.idLocal },
-          parentId: { global: row.parentIdGlobal, local: row.parentIdLocal },
-          mutation: row.mutation,
-          args: argsDecoded,
-        } satisfies MutationEvent.AnyDecoded
-
-        const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
-
-        const makeExecuteOptions = (statementSql: string, bindValues: any) => ({
-          onRowsChanged: (rowsChanged: number) => {
-            if (rowsChanged === 0 && migrationOptions.logging?.excludeAffectedRows?.(statementSql) !== true) {
-              console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
-            }
-          },
-        })
-
-        for (const { statementSql, bindValues } of execArgsArr) {
-          // TODO cache prepared statements for mutations
-          db.execute(statementSql, bindValues, isDevEnv() ? makeExecuteOptions(statementSql, bindValues) : undefined)
-          // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
-        }
-      }).pipe(Effect.withSpan(`@livestore/common:rehydrateFromMutationLog:processMutation`))
-
-    const CHUNK_SIZE = 100
-
-    const stmt = logDb.prepare(sql`\
-SELECT * FROM ${MUTATION_LOG_META_TABLE} 
-WHERE idGlobal > $idGlobal OR (idGlobal = $idGlobal AND idLocal > $idLocal)
-ORDER BY idGlobal ASC, idLocal ASC
-LIMIT ${CHUNK_SIZE}
-`)
-
-    let processedMutations = 0
-
-    yield* Stream.unfoldChunk<Chunk.Chunk<MutationLogMetaRow> | { _tag: 'Initial ' }, MutationLogMetaRow>(
-      { _tag: 'Initial ' },
-      (item) => {
-        // End stream if no more rows
-        if (Chunk.isChunk(item) && item.length === 0) return Option.none()
-
-        const lastId = Chunk.isChunk(item)
-          ? Chunk.last(item).pipe(
-              Option.map((_) => ({ global: _.idGlobal, local: _.idLocal })),
-              Option.getOrElse(() => EventId.ROOT),
-            )
-          : EventId.ROOT
-        const nextItem = Chunk.fromIterable(
-          stmt.select<MutationLogMetaRow>({
-            $idGlobal: lastId?.global,
-            $idLocal: lastId?.local,
-          } as any as PreparedBindValues),
-        )
-        const prevItem = Chunk.isChunk(item) ? item : Chunk.empty()
-        return Option.some([prevItem, nextItem])
-      },
-    ).pipe(
-      Stream.bufferChunks({ capacity: 2 }),
-      Stream.tap((row) =>
-        Effect.gen(function* () {
-          yield* processMutation(row)
-
-          processedMutations++
-          yield* onProgress({ done: processedMutations, total: mutationsCount })
-        }),
-      ),
-      Stream.runDrain,
-    )
-  }).pipe(
-    Effect.withPerformanceMeasure('@livestore/common:rehydrateFromMutationLog'),
-    Effect.withSpan('@livestore/common:rehydrateFromMutationLog'),
-  )

package/src/schema/EventId.ts

@@ -1,60 +0,0 @@
-import { Brand, Schema } from '@livestore/utils/effect'
-
-export type LocalEventId = Brand.Branded<number, 'LocalEventId'>
-export const localEventId = Brand.nominal<LocalEventId>()
-export const LocalEventId = Schema.fromBrand(localEventId)(Schema.Int)
-
-export type GlobalEventId = Brand.Branded<number, 'GlobalEventId'>
-export const globalEventId = Brand.nominal<GlobalEventId>()
-export const GlobalEventId = Schema.fromBrand(globalEventId)(Schema.Int)
-
-export const localDefault = 0 as any as LocalEventId
-
-/**
- * LiveStore event id value consisting of a globally unique event sequence number
- * and a local sequence number.
- *
- * The local sequence number is only used for localOnly mutations and starts from 0 for each global sequence number.
- */
-export type EventId = { global: GlobalEventId; local: LocalEventId }
-
-export const EventId = Schema.Struct({
-  global: GlobalEventId,
-  local: LocalEventId,
-}).annotations({ title: 'LiveStore.EventId' })
-
-/**
- * Compare two event ids i.e. checks if the first event id is less than the second.
- */
-export const compare = (a: EventId, b: EventId) => {
-  if (a.global !== b.global) {
-    return a.global - b.global
-  }
-  return a.local - b.local
-}
-
-export const isEqual = (a: EventId, b: EventId) => a.global === b.global && a.local === b.local
-
-export type EventIdPair = { id: EventId; parentId: EventId }
-
-export const ROOT = { global: -1 as any as GlobalEventId, local: localDefault } satisfies EventId
-
-export const isGreaterThan = (a: EventId, b: EventId) => {
-  return a.global > b.global || (a.global === b.global && a.local > b.local)
-}
-
-export const make = (id: EventId | typeof EventId.Encoded): EventId => {
-  return Schema.is(EventId)(id) ? id : Schema.decodeSync(EventId)(id)
-}
-
-export const nextPair = (id: EventId, isLocal: boolean): EventIdPair => {
-  if (isLocal) {
-    return { id: { global: id.global, local: (id.local + 1) as any as LocalEventId }, parentId: id }
-  }
-
-  return {
-    id: { global: (id.global + 1) as any as GlobalEventId, local: localDefault },
-    // NOTE we always point to `local: 0` for non-localOnly mutations
-    parentId: { global: id.global, local: localDefault },
-  }
-}

package/src/schema/MutationEvent.ts

@@ -1,180 +0,0 @@
-import { memoizeByRef } from '@livestore/utils'
-import type { Deferred } from '@livestore/utils/effect'
-import { Schema } from '@livestore/utils/effect'
-
-import * as EventId from './EventId.js'
-import type { MutationDef, MutationDefRecord } from './mutations.js'
-import type { LiveStoreSchema } from './schema.js'
-
-export type MutationEventPartial<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.Type<TMutationsDef['schema']>
-}
-
-export type MutationEventPartialEncoded<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.Encoded<TMutationsDef['schema']>
-}
-
-export type MutationEvent<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.Type<TMutationsDef['schema']>
-  id: EventId.EventId
-  parentId: EventId.EventId
-}
-
-export type MutationEventEncoded<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.Encoded<TMutationsDef['schema']>
-  id: EventId.EventId
-  parentId: EventId.EventId
-}
-
-export type AnyDecoded = MutationEvent<MutationDef.Any>
-export const AnyDecoded = Schema.Struct({
-  mutation: Schema.String,
-  args: Schema.Any,
-  id: EventId.EventId,
-  parentId: EventId.EventId,
-}).annotations({ title: 'MutationEvent.AnyDecoded' })
-
-export type AnyEncoded = MutationEventEncoded<MutationDef.Any>
-export const AnyEncoded = Schema.Struct({
-  mutation: Schema.String,
-  args: Schema.Any,
-  id: EventId.EventId,
-  parentId: EventId.EventId,
-}).annotations({ title: 'MutationEvent.AnyEncoded' })
-
-export const AnyEncodedGlobal = Schema.Struct({
-  mutation: Schema.String,
-  args: Schema.Any,
-  id: EventId.GlobalEventId,
-  parentId: EventId.GlobalEventId,
-}).annotations({ title: 'MutationEvent.AnyEncodedGlobal' })
-export type AnyEncodedGlobal = typeof AnyEncodedGlobal.Type
-
-export type PartialAny = MutationEventPartial<MutationDef.Any>
-export type PartialAnyEncoded = MutationEventPartialEncoded<MutationDef.Any>
-
-export type PartialForSchema<TSchema extends LiveStoreSchema> = {
-  [K in keyof TSchema['_MutationDefMapType']]: MutationEventPartial<TSchema['_MutationDefMapType'][K]>
-}[keyof TSchema['_MutationDefMapType']]
-
-export type ForSchema<TSchema extends LiveStoreSchema> = {
-  [K in keyof TSchema['_MutationDefMapType']]: MutationEvent<TSchema['_MutationDefMapType'][K]>
-}[keyof TSchema['_MutationDefMapType']]
-
-export const isPartialMutationEvent = (mutationEvent: AnyDecoded | PartialAny): mutationEvent is PartialAny =>
-  'id' in mutationEvent === false && 'parentId' in mutationEvent === false
-
-export type ForMutationDefRecord<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
-  {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.Type<TMutationsDefRecord[K]['schema']>
-      id: EventId.EventId
-      parentId: EventId.EventId
-    }
-  }[keyof TMutationsDefRecord],
-  {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.Encoded<TMutationsDefRecord[K]['schema']>
-      id: EventId.EventId
-      parentId: EventId.EventId
-    }
-  }[keyof TMutationsDefRecord]
->
-
-export type MutationEventPartialSchema<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
-  {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.Type<TMutationsDefRecord[K]['schema']>
-    }
-  }[keyof TMutationsDefRecord],
-  {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.Encoded<TMutationsDefRecord[K]['schema']>
-    }
-  }[keyof TMutationsDefRecord]
->
-
-export const makeMutationEventSchema = <TSchema extends LiveStoreSchema>(
-  schema: TSchema,
-): ForMutationDefRecord<TSchema['_MutationDefMapType']> =>
-  Schema.Union(
-    ...[...schema.mutations.values()].map((def) =>
-      Schema.Struct({
-        mutation: Schema.Literal(def.name),
-        args: def.schema,
-        id: EventId.EventId,
-        parentId: EventId.EventId,
-      }),
-    ),
-  ).annotations({ title: 'MutationEvent' }) as any
-
-export const makeMutationEventPartialSchema = <TSchema extends LiveStoreSchema>(
-  schema: TSchema,
-): MutationEventPartialSchema<TSchema['_MutationDefMapType']> =>
-  Schema.Union(
-    ...[...schema.mutations.values()].map((def) =>
-      Schema.Struct({
-        mutation: Schema.Literal(def.name),
-        args: def.schema,
-      }),
-    ),
-  ).annotations({ title: 'MutationEventSchemaPartial' }) as any
-
-export const makeMutationEventSchemaMemo = memoizeByRef(makeMutationEventSchema)
-
-/** Equivalent to AnyEncoded but with a meta field and some convenience methods */
-export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEvent.EncodedWithMeta')({
-  mutation: Schema.String,
-  args: Schema.Any,
-  id: EventId.EventId,
-  parentId: EventId.EventId,
-  meta: Schema.optionalWith(
-    Schema.Any as Schema.Schema<{ deferred?: Deferred.Deferred<void>; sessionChangeset?: Uint8Array }>,
-    { default: () => ({}) },
-  ),
-}) {
-  toJSON = (): any => {
-    // Only used for logging/debugging
-    // - More readable way to print the id + parentId
-    // - not including `meta`
-    return {
-      id: `(${this.id.global},${this.id.local}) → (${this.parentId.global},${this.parentId.local})`,
-      mutation: this.mutation,
-      args: this.args,
-    }
-  }
-
-  rebase = (parentId: EventId.EventId, isLocal: boolean) =>
-    new EncodedWithMeta({
-      ...this,
-      ...EventId.nextPair(this.id, isLocal),
-    })
-
-  static fromGlobal = (mutationEvent: AnyEncodedGlobal) =>
-    new EncodedWithMeta({
-      ...mutationEvent,
-      id: { global: mutationEvent.id, local: EventId.localDefault },
-      parentId: { global: mutationEvent.parentId, local: EventId.localDefault },
-    })
-
-  toGlobal = (): AnyEncodedGlobal => ({
-    ...this,
-    id: this.id.global,
-    parentId: this.parentId.global,
-  })
-}
-
-export const isEqualEncoded = (a: AnyEncoded, b: AnyEncoded) =>
-  a.id.global === b.id.global &&
-  a.id.local === b.id.local &&
-  a.mutation === b.mutation &&
-  // TODO use schema equality here
-  JSON.stringify(a.args) === JSON.stringify(b.args)

package/src/schema/mutations.ts

@@ -1,192 +0,0 @@
-import { Schema } from '@livestore/utils/effect'
-
-import type { BindValues } from '../sql-queries/sql-queries.js'
-import type * as EventId from './EventId.js'
-
-export type MutationDefMap = Map<string | 'livestore.RawSql', MutationDef.Any>
-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) => SingleOrReadonlyArray<
-      | string
-      | {
-          sql: string
-          /** Note args need to be manually encoded to `BindValues` when returning this argument */
-          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 over the network
-     */
-    localOnly: boolean
-    /** Warning: This feature is not fully implemented yet */
-    facts: FactsCallback<TTo> | undefined
-  }
-
-  /** Helper function to construct a partial mutation event */
-  (
-    args: TTo,
-    options?: {
-      id?: number
-    },
-  ): {
-    mutation: TName
-    args: TTo
-    // TODO remove/clean up after sync-next is fully implemented
-    id?: EventId.EventId
-  }
-}
-
-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
-   */
-  localOnly?: 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,
-    options?: {
-      id?: EventId.EventId
-    },
-  ) => ({ mutation: name, args, ...options })
-
-  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',
-      localOnly: options?.localOnly ?? 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>

package/src/schema/system-tables.ts

@@ -1,104 +0,0 @@
-import { type SqliteAst as __SqliteAst, SqliteDsl } from '@livestore/db-schema'
-import { Schema } from '@livestore/utils/effect'
-
-import * as EventId from './EventId.js'
-import type { FromTable } from './table-def.js'
-import { table } from './table-def.js'
-
-/// App DB
-
-export const SCHEMA_META_TABLE = '__livestore_schema'
-
-export const schemaMetaTable = table(
-  SCHEMA_META_TABLE,
-  {
-    tableName: SqliteDsl.text({ primaryKey: true }),
-    schemaHash: SqliteDsl.integer({ nullable: false }),
-    /** ISO date format */
-    updatedAt: SqliteDsl.text({ nullable: false }),
-  },
-  { disableAutomaticIdColumn: true },
-)
-
-export type SchemaMetaRow = FromTable.RowDecoded<typeof schemaMetaTable>
-
-export const SCHEMA_MUTATIONS_META_TABLE = '__livestore_schema_mutations'
-
-export const schemaMutationsMetaTable = table(
-  SCHEMA_MUTATIONS_META_TABLE,
-  {
-    mutationName: SqliteDsl.text({ primaryKey: true }),
-    schemaHash: SqliteDsl.integer({ nullable: false }),
-    /** ISO date format */
-    updatedAt: SqliteDsl.text({ nullable: false }),
-  },
-  { disableAutomaticIdColumn: true },
-)
-
-export type SchemaMutationsMetaRow = FromTable.RowDecoded<typeof schemaMutationsMetaTable>
-
-/**
- * Table which stores SQLite changeset blobs which is used for rolling back
- * read-model state during rebasing.
- */
-export const SESSION_CHANGESET_META_TABLE = '__livestore_session_changeset'
-
-export const sessionChangesetMetaTable = table(
-  SESSION_CHANGESET_META_TABLE,
-  {
-    // TODO bring back primary key
-    idGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
-    idLocal: SqliteDsl.integer({ schema: EventId.LocalEventId }),
-    // idGlobal: SqliteDsl.integer({ primaryKey: true }),
-    // idLocal: SqliteDsl.integer({ primaryKey: true }),
-    changeset: SqliteDsl.blob({}),
-    debug: SqliteDsl.json({ nullable: true }),
-  },
-  { disableAutomaticIdColumn: true },
-)
-
-export type SessionChangesetMetaRow = FromTable.RowDecoded<typeof sessionChangesetMetaTable>
-
-export const systemTables = [schemaMetaTable, schemaMutationsMetaTable, sessionChangesetMetaTable]
-
-/// Mutation log DB
-
-export const SyncStatus = Schema.Literal('synced', 'pending', 'error', 'localOnly')
-export type SyncStatus = typeof SyncStatus.Type
-
-export const MUTATION_LOG_META_TABLE = 'mutation_log'
-
-export const mutationLogMetaTable = table(
-  MUTATION_LOG_META_TABLE,
-  {
-    idGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventId.GlobalEventId }),
-    idLocal: SqliteDsl.integer({ primaryKey: true, schema: EventId.LocalEventId }),
-    parentIdGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
-    parentIdLocal: SqliteDsl.integer({ schema: EventId.LocalEventId }),
-    mutation: SqliteDsl.text({}),
-    argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
-    schemaHash: SqliteDsl.integer({}),
-    syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
-  },
-  {
-    disableAutomaticIdColumn: true,
-    indexes: [
-      { columns: ['idGlobal'], name: 'idx_idGlobal' },
-      { columns: ['idGlobal', 'idLocal'], name: 'idx_idGlobal_idLocal' },
-    ],
-  },
-)
-
-export type MutationLogMetaRow = FromTable.RowDecoded<typeof mutationLogMetaTable>
-
-export const SYNC_STATUS_TABLE = '__livestore_sync_status'
-
-export const syncStatusTable = table(
-  SYNC_STATUS_TABLE,
-  {
-    head: SqliteDsl.integer({ primaryKey: true }),
-  },
-  { disableAutomaticIdColumn: true },
-)
-
-export type SyncStatusRow = FromTable.RowDecoded<typeof syncStatusTable>