@livestore/common 0.0.47-dev.0 → 0.0.48-dev.0

package/src/schema/parse-utils.ts

@@ -8,7 +8,7 @@ import { type FromColumns, type FromTable, getDefaultValuesDecoded, type TableDe
 export const many = <TTableDef extends TableDef>(
   table: TTableDef,
 ): ((rawRows: ReadonlyArray<any>) => ReadonlyArray<FromTable.RowDecoded<TTableDef>>) => {
-  return Schema.decodeSync(Schema.array(table.schema)) as TODO
+  return Schema.decodeSync(Schema.Array(table.schema)) as TODO
 }
 
 export const first =
@@ -17,7 +17,7 @@ export const first =
     fallback?: FromColumns.InsertRowDecoded<TTableDef['sqliteDef']['columns']>,
   ) =>
   (rawRows: ReadonlyArray<any>) => {
-    const rows = Schema.decodeSync(Schema.array(table.schema))(rawRows)
+    const rows = Schema.decodeSync(Schema.Array(table.schema))(rawRows)
 
     if (rows.length === 0) {
       const schemaDefaultValues = getDefaultValuesDecoded(table)
@@ -31,7 +31,7 @@ export const first =
       if (defaultValuesResult._tag === 'Right') {
         return defaultValuesResult.right
       } else {
-        console.error('decode error', TreeFormatter.formatError(defaultValuesResult.left))
+        console.error('decode error', TreeFormatter.formatErrorSync(defaultValuesResult.left))
         return shouldNeverHappen(
           `Expected query (for table ${table.sqliteDef.name}) to return at least one result but found none. Also can't fallback to default values as some were not provided.`,
         )

package/src/schema/system-tables.ts

@@ -1,12 +1,14 @@
-// import { Schema as __Schema } from '@livestore/utils/effect'
+import { Schema } from '@livestore/utils/effect'
 import { type SqliteAst as __SqliteAst, SqliteDsl } from 'effect-db-schema'
 
 import type { FromTable } from './table-def.js'
 import { table } from './table-def.js'
 
+/// App DB
+
 export const SCHEMA_META_TABLE = '__livestore_schema'
 
-const schemaMetaTable = table(
+export const schemaMetaTable = table(
   SCHEMA_META_TABLE,
   {
     tableName: SqliteDsl.text({ primaryKey: true }),
@@ -19,4 +21,43 @@ const schemaMetaTable = table(
 
 export type SchemaMetaRow = FromTable.RowDecoded<typeof schemaMetaTable>
 
-export const systemTables = [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>
+
+export const systemTables = [schemaMetaTable, schemaMutationsMetaTable]
+
+/// Mutation log DB
+
+export const SyncStatus = Schema.Literal('synced', 'pending', 'error')
+export type SyncStatus = typeof SyncStatus.Type
+
+export const MUTATION_LOG_META_TABLE = 'mutation_log'
+
+export const mutationLogMetaTable = table(
+  MUTATION_LOG_META_TABLE,
+  {
+    // TODO add parent ids (see https://vlcn.io/blog/crdt-substrate)
+    id: SqliteDsl.text({ primaryKey: true }),
+    mutation: SqliteDsl.text({ nullable: false }),
+    argsJson: SqliteDsl.text({ nullable: false, schema: Schema.parseJson(Schema.Any) }),
+    schemaHash: SqliteDsl.integer({ nullable: false }),
+    /** ISO date format */
+    createdAt: SqliteDsl.text({ nullable: false }),
+    syncStatus: SqliteDsl.text({ schema: SyncStatus }),
+  },
+  { disableAutomaticIdColumn: true },
+)
+
+export type MutationLogMetaRow = FromTable.RowDecoded<typeof mutationLogMetaTable>

package/src/schema/table-def.ts

@@ -3,6 +3,9 @@ import { pipe, ReadonlyRecord, Schema } from '@livestore/utils/effect'
 import type { Nullable, PrettifyFlat } from 'effect-db-schema'
 import { SqliteDsl } from 'effect-db-schema'
 
+import type { DerivedMutationHelperFns } from '../derived-mutations.js'
+import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
+
 export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
 
 export { type SqliteDsl } from 'effect-db-schema'
@@ -53,26 +56,42 @@ export type TableDef<
   >,
 > = {
   sqliteDef: TSqliteDef
+  // TODO move this into options (for now it's duplicated)
   isSingleColumn: TIsSingleColumn
   options: TOptions
   schema: TSchema
-}
+} & (TOptions['deriveMutations'] extends true ? DerivedMutationHelperFns<TSqliteDef['columns'], TOptions> : {})
 
-export type TableOptionsInput = Partial<TableOptions & { indexes: SqliteDsl.Index[] }>
+export type TableOptionsInput = Partial<Omit<TableOptions, 'isSingleColumn'> & { indexes: SqliteDsl.Index[] }>
 
 export type TableOptions = {
   /**
    * Setting this to true will have the following consequences:
    * - An `id` column will be added with `primaryKey: true` and `"singleton"` as default value and only allowed value
-   * - LiveStore will automatically create the singleton row when the table is created
+   * - LiveStore will automatically create the singleton row when booting up
    * - LiveStore will fail if there is already a column defined with `primaryKey: true`
    *
    * @default false
    */
   isSingleton: boolean
-  // TODO
+  // TODO remove
   dynamicRegistration: boolean
   disableAutomaticIdColumn: boolean
+  /**
+   * Setting this to true will automatically derive insert, update and delete mutations for this table. Example:
+   *
+   * ```ts
+   * const todos = table('todos', { ... }, { deriveMutations: true })
+   * todos.insert({ id: '1', text: 'Hello' })
+   * ```
+   *
+   * This is also a prerequisite for using the `useRow`, `useAtom` and `rowQuery` APIs.
+   *
+   * Important: When using this option, make sure you're following the "Rules of mutations" for the table schema.
+   */
+  deriveMutations: boolean
+  /** Derived based on whether the table definition has one or more columns (besides the `id` column) */
+  isSingleColumn: boolean
 }
 
 export const table = <
@@ -82,17 +101,19 @@ export const table = <
 >(
   name: TName,
   columnOrColumns: TColumns,
-  // type?: TStateType,
   options?: TOptionsInput,
 ): TableDef<
   SqliteDsl.TableDefinition<
     TName,
     PrettifyFlat<
-      WithId<TColumns extends SqliteDsl.Columns ? TColumns : { value: TColumns }, WithDefaults<TOptionsInput>>
+      WithId<
+        TColumns extends SqliteDsl.Columns ? TColumns : { value: TColumns },
+        WithDefaults<TOptionsInput, SqliteDsl.IsSingleColumn<TColumns>>
+      >
     >
   >,
-  TColumns extends SqliteDsl.ColumnDefinition<any, any> ? true : false,
-  WithDefaults<TOptionsInput>
+  SqliteDsl.IsSingleColumn<TColumns>,
+  WithDefaults<TOptionsInput, SqliteDsl.IsSingleColumn<TColumns>>
 > => {
   const tablePath = name
 
@@ -100,6 +121,8 @@ export const table = <
     isSingleton: options?.isSingleton ?? false,
     dynamicRegistration: options?.dynamicRegistration ?? false,
     disableAutomaticIdColumn: options?.disableAutomaticIdColumn ?? false,
+    deriveMutations: options?.deriveMutations ?? false,
+    isSingleColumn: SqliteDsl.isColumnDefinition(columnOrColumns) === true,
   }
 
   const columns = (
@@ -114,7 +137,7 @@ export const table = <
     }
   } else if (columns.id === undefined && ReadonlyRecord.some(columns, (_) => _.primaryKey === true) === false) {
     if (options_.isSingleton) {
-      columns.id = SqliteDsl.text({ schema: Schema.literal('singleton'), primaryKey: true, default: 'singleton' })
+      columns.id = SqliteDsl.text({ schema: Schema.Literal('singleton'), primaryKey: true, default: 'singleton' })
     } else {
       columns.id = SqliteDsl.text({ primaryKey: true })
     }
@@ -122,6 +145,7 @@ export const table = <
 
   const sqliteDef = SqliteDsl.table(tablePath, columns, options?.indexes ?? [])
 
+  // TODO also enforce this on the type level
   if (options_.isSingleton) {
     for (const column of sqliteDef.ast.columns) {
       if (column.nullable === false && column.default._tag === 'None') {
@@ -137,18 +161,38 @@ export const table = <
   const schema = SqliteDsl.structSchemaForTable(sqliteDef)
   const tableDef = { sqliteDef, isSingleColumn, options: options_, schema } satisfies TableDef
 
-  // if (dynamicallyRegisteredTables.has(tablePath)) {
-  //   if (SqliteAst.hash(dynamicallyRegisteredTables.get(tablePath)!.sqliteDef.ast) !== SqliteAst.hash(sqliteDef.ast)) {
-  //     console.error('previous tableDef', dynamicallyRegisteredTables.get(tablePath), 'new tableDef', sqliteDef.ast)
-  //     shouldNeverHappen(`Table with name "${name}" was already previously defined with a different definition`)
-  //   }
-  // } else {
-  //   dynamicallyRegisteredTables.set(tablePath, tableDef)
-  // }
+  if (tableHasDerivedMutations(tableDef)) {
+    const derivedMutationDefs = makeDerivedMutationDefsForTable(tableDef)
+
+    tableDef.insert = (valuesOrValue: any) => {
+      if (isSingleColumn && options_.isSingleton) {
+        return derivedMutationDefs.insert({ id: 'singleton', value: { value: valuesOrValue } })
+      } else {
+        return derivedMutationDefs.insert(valuesOrValue as any)
+      }
+    }
+
+    tableDef.update = (argsOrValues: any) => {
+      if (isSingleColumn && options_.isSingleton) {
+        return derivedMutationDefs.update({ where: { id: 'singleton' }, values: { value: argsOrValues } as any })
+      } else {
+        return derivedMutationDefs.update(argsOrValues as any)
+      }
+    }
+
+    tableDef.delete = (args: any) => derivedMutationDefs.delete(args)
+  }
 
   return tableDef as any
 }
 
+export const tableHasDerivedMutations = <TTableDef extends TableDef>(
+  tableDef: TTableDef,
+): tableDef is TTableDef & {
+  options: { deriveMutations: true }
+} & DerivedMutationHelperFns<TTableDef['sqliteDef']['columns'], TTableDef['options']> =>
+  tableDef.options.deriveMutations === true
+
 export const tableIsSingleton = <TTableDef extends TableDef>(
   tableDef: TTableDef,
 ): tableDef is TTableDef & { options: { isSingleton: true } } => tableDef.options.isSingleton === true
@@ -210,10 +254,12 @@ type WithId<TColumns extends SqliteDsl.Columns, TOptions extends TableOptions> =
             id: SqliteDsl.ColumnDefinition<string, string>
           })
 
-type WithDefaults<TOptionsInput extends TableOptionsInput> = {
+type WithDefaults<TOptionsInput extends TableOptionsInput, TIsSingleColumn extends boolean> = {
   isSingleton: TOptionsInput['isSingleton'] extends true ? true : false
   dynamicRegistration: TOptionsInput['dynamicRegistration'] extends true ? true : false
   disableAutomaticIdColumn: TOptionsInput['disableAutomaticIdColumn'] extends true ? true : false
+  deriveMutations: TOptionsInput['deriveMutations'] extends true ? true : false
+  isSingleColumn: TIsSingleColumn
 }
 
 export namespace FromTable {

package/src/schema-management/common.ts

@@ -0,0 +1,29 @@
+import type { InMemoryDatabase } from '../adapter-types.js'
+import type { ParamsObject } from '../util.js'
+import { prepareBindValues } from '../util.js'
+
+// TODO bring back statement caching
+// will require proper scope-aware cleanup etc (for testing and apps with multiple LiveStore instances)
+// const cachedStmts = new Map<string, PreparedStatement>()
+
+export const dbExecute = (db: InMemoryDatabase, queryStr: string, bindValues?: ParamsObject) => {
+  // let stmt = cachedStmts.get(queryStr)
+  // if (!stmt) {
+  const stmt = db.prepare(queryStr)
+  // cachedStmts.set(queryStr, stmt)
+  // }
+
+  const preparedBindValues = bindValues ? prepareBindValues(bindValues, queryStr) : undefined
+
+  stmt.execute(preparedBindValues)
+}
+
+export const dbSelect = <T>(db: InMemoryDatabase, queryStr: string, bindValues?: ParamsObject) => {
+  // let stmt = cachedStmts.get(queryStr)
+  // if (!stmt) {
+  const stmt = db.prepare(queryStr)
+  // cachedStmts.set(queryStr, stmt)
+  // }
+
+  return stmt.select<T>(bindValues ? prepareBindValues(bindValues, queryStr) : undefined)
+}

package/src/{migrations.ts → schema-management/migrations.ts}

@@ -1,58 +1,36 @@
-import { memoize } from '@livestore/utils'
+import { memoizeByStringifyArgs } from '@livestore/utils'
 import { Schema as EffectSchema } from '@livestore/utils/effect'
-import type * as otel from '@opentelemetry/api'
+import * as otel from '@opentelemetry/api'
 import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
-import type { MainDatabase } from './database.js'
-import type { LiveStoreSchema } from './schema/index.js'
-import type { SchemaMetaRow } from './schema/system-tables.js'
-import { SCHEMA_META_TABLE, systemTables } from './schema/system-tables.js'
-import type { ParamsObject } from './util.js'
-import { prepareBindValues, sql } from './util.js'
+import type { InMemoryDatabase } from '../adapter-types.js'
+import type { LiveStoreSchema } from '../schema/index.js'
+import type { SchemaMetaRow } from '../schema/system-tables.js'
+import { SCHEMA_META_TABLE, schemaMetaTable, systemTables } from '../schema/system-tables.js'
+import { sql } from '../util.js'
+import { dbExecute, dbSelect } from './common.js'
+import { makeSchemaManager, validateSchema } from './validate-mutation-defs.js'
 
-const getMemoizedTimestamp = memoize(() => new Date().toISOString())
-
-// TODO bring back statement caching
-// will require proper scope-aware cleanup etc (for testing and apps with multiple LiveStore instances)
-// const cachedStmts = new Map<string, PreparedStatement>()
-
-const dbExecute = (db: MainDatabase, queryStr: string, bindValues?: ParamsObject) => {
-  // let stmt = cachedStmts.get(queryStr)
-  // if (!stmt) {
-  const stmt = db.prepare(queryStr)
-  // cachedStmts.set(queryStr, stmt)
-  // }
-
-  const preparedBindValues = bindValues ? prepareBindValues(bindValues, queryStr) : undefined
-
-  stmt.execute(preparedBindValues)
-}
-
-const dbSelect = <T>(db: MainDatabase, queryStr: string, bindValues?: ParamsObject) => {
-  // let stmt = cachedStmts.get(queryStr)
-  // if (!stmt) {
-  const stmt = db.prepare(queryStr)
-  // cachedStmts.set(queryStr, stmt)
-  // }
-
-  return stmt.select<T>(bindValues ? prepareBindValues(bindValues, queryStr) : undefined)
-}
+const getMemoizedTimestamp = memoizeByStringifyArgs(() => new Date().toISOString())
 
 // TODO more graceful DB migration (e.g. backup DB before destructive migrations)
 export const migrateDb = ({
   db,
-  otelContext,
+  otelContext = otel.context.active(),
   schema,
 }: {
-  db: MainDatabase
-  otelContext: otel.Context
+  db: InMemoryDatabase
+  otelContext?: otel.Context
   schema: LiveStoreSchema
 }) => {
-  dbExecute(
+  migrateTable({
     db,
-    // 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);`,
-  )
+    otelContext,
+    tableAst: schemaMetaTable.sqliteDef.ast,
+    behaviour: 'create-if-not-exists',
+  })
+
+  validateSchema(schema, makeSchemaManager(db))
 
   const schemaMetaRows = dbSelect<SchemaMetaRow>(db, sql`SELECT * FROM ${SCHEMA_META_TABLE}`)
 
@@ -72,7 +50,6 @@ export const migrateDb = ({
     const dbSchemaHash = dbSchemaHashByTable[tableName]
     const schemaHash = SqliteAst.hash(tableAst)
 
-    // @ts-expect-error TODO fix typing
     const skipMigrations = import.meta.env.VITE_LIVESTORE_SKIP_MIGRATIONS !== undefined
 
     if (schemaHash !== dbSchemaHash && skipMigrations === false) {
@@ -80,7 +57,7 @@ export const migrateDb = ({
         `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), migrating table...`,
       )
 
-      migrateTable({ db, tableAst, otelContext, schemaHash })
+      migrateTable({ db, tableAst, otelContext, schemaHash, behaviour: 'drop-and-recreate' })
     }
   }
 }
@@ -89,35 +66,45 @@ export const migrateTable = ({
   db,
   tableAst,
   // otelContext,
-  schemaHash,
+  schemaHash = SqliteAst.hash(tableAst),
+  behaviour,
+  skipMetaTable = false,
 }: {
-  db: MainDatabase
+  db: InMemoryDatabase
   tableAst: SqliteAst.Table
-  otelContext: otel.Context
-  schemaHash: number
+  otelContext?: otel.Context
+  schemaHash?: number
+  behaviour: 'drop-and-recreate' | 'create-if-not-exists'
+  skipMetaTable?: boolean
 }) => {
   console.log(`Migrating table '${tableAst.name}'...`)
   const tableName = tableAst.name
   const columnSpec = makeColumnSpec(tableAst)
 
-  // TODO need to possibly handle cascading deletes due to foreign keys
-  dbExecute(db, sql`drop table if exists ${tableName}`)
-  dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec})`)
+  if (behaviour === 'drop-and-recreate') {
+    // TODO need to possibly handle cascading deletes due to foreign keys
+    dbExecute(db, sql`drop table if exists ${tableName}`)
+    dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
+  } else if (behaviour === 'create-if-not-exists') {
+    dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
+  }
 
   for (const index of tableAst.indexes) {
     dbExecute(db, createIndexFromDefinition(tableName, index))
   }
 
-  const updatedAt = getMemoizedTimestamp()
+  if (skipMetaTable !== true) {
+    const updatedAt = getMemoizedTimestamp()
 
-  dbExecute(
-    db,
-    sql`
+    dbExecute(
+      db,
+      sql`
       INSERT INTO ${SCHEMA_META_TABLE} (tableName, schemaHash, updatedAt) VALUES ($tableName, $schemaHash, $updatedAt)
         ON CONFLICT (tableName) DO UPDATE SET schemaHash = $schemaHash, updatedAt = $updatedAt;
     `,
-    { tableName, schemaHash, updatedAt },
-  )
+      { tableName, schemaHash, updatedAt },
+    )
+  }
 }
 
 const createIndexFromDefinition = (tableName: string, index: SqliteAst.Index) => {

package/src/schema-management/validate-mutation-defs.ts

@@ -0,0 +1,108 @@
+import { shouldNeverHappen } from '@livestore/utils'
+import { Schema } from '@livestore/utils/effect'
+import * as otel from '@opentelemetry/api'
+
+import type { InMemoryDatabase } from '../adapter-types.js'
+import type { LiveStoreSchema } from '../schema/index.js'
+import type { MutationDef } from '../schema/mutations.js'
+import type { SchemaMutationsMetaRow } from '../schema/system-tables.js'
+import { SCHEMA_MUTATIONS_META_TABLE, schemaMutationsMetaTable } from '../schema/system-tables.js'
+import { sql } from '../util.js'
+import { dbExecute, dbSelect } from './common.js'
+import { migrateTable } from './migrations.js'
+
+export const validateSchema = (schema: LiveStoreSchema, schemaManager: SchemaManager) => {
+  // Validate mutation definitions
+  const registeredMutationDefInfos = schemaManager.getMutationDefInfos()
+
+  const missingMutationDefs = registeredMutationDefInfos.filter(
+    (registeredMutationDefInfo) => !schema.mutations.has(registeredMutationDefInfo.mutationName),
+  )
+
+  if (missingMutationDefs.length > 0) {
+    shouldNeverHappen(
+      `Missing mutation definitions: ${missingMutationDefs.map((info) => info.mutationName).join(', ')}`,
+    )
+  }
+
+  for (const [, mutationDef] of schema.mutations) {
+    const registeredMutationDefInfo = registeredMutationDefInfos.find((info) => info.mutationName === mutationDef.name)
+
+    validateMutationDef(mutationDef, schemaManager, registeredMutationDefInfo)
+  }
+
+  // Validate table schemas
+}
+
+export const validateMutationDef = (
+  mutationDef: MutationDef.Any,
+  schemaManager: SchemaManager,
+  registeredMutationDefInfo: MutationDefInfo | undefined,
+) => {
+  const schemaHash = Schema.hash(mutationDef.schema)
+
+  if (registeredMutationDefInfo === undefined) {
+    schemaManager.setMutationDefInfo({
+      schemaHash,
+      mutationName: mutationDef.name,
+    })
+
+    return
+  }
+
+  if (schemaHash === registeredMutationDefInfo.schemaHash) return
+
+  // TODO bring back some form of schema compatibility check (see https://github.com/livestorejs/livestore/issues/69)
+  // const newSchemaIsCompatibleWithOldSchema = Schema.isSubType(jsonSchemaDefFromMgmtStore, mutationDef.schema)
+
+  // if (!newSchemaIsCompatibleWithOldSchema) {
+  //   shouldNeverHappen(`Schema for mutation ${mutationDef.name} has changed in an incompatible way`)
+  // }
+
+  schemaManager.setMutationDefInfo({
+    schemaHash,
+    mutationName: mutationDef.name,
+  })
+}
+
+interface SchemaManager {
+  getMutationDefInfos: () => ReadonlyArray<MutationDefInfo>
+
+  setMutationDefInfo: (mutationDefInfo: MutationDefInfo) => void
+}
+
+type MutationDefInfo = {
+  mutationName: string
+  schemaHash: number
+}
+
+export const makeSchemaManager = (db: InMemoryDatabase): SchemaManager => {
+  migrateTable({
+    db,
+    otelContext: otel.context.active(),
+    tableAst: schemaMutationsMetaTable.sqliteDef.ast,
+    behaviour: 'create-if-not-exists',
+  })
+
+  return {
+    getMutationDefInfos: () => {
+      const schemaMutationsMetaRows = dbSelect<SchemaMutationsMetaRow>(
+        db,
+        sql`SELECT * FROM ${SCHEMA_MUTATIONS_META_TABLE}`,
+      )
+
+      return schemaMutationsMetaRows
+    },
+    setMutationDefInfo: (info) => {
+      dbExecute(
+        db,
+        sql`INSERT OR REPLACE INTO ${SCHEMA_MUTATIONS_META_TABLE} (mutationName, schemaHash, updatedAt) VALUES ($mutationName, $schemaHash, $updatedAt)`,
+        {
+          mutationName: info.mutationName,
+          schemaHash: info.schemaHash,
+          updatedAt: new Date().toISOString(),
+        },
+      )
+    },
+  }
+}

package/src/sql-queries/sql-queries.ts

@@ -1,3 +1,4 @@
+import { shouldNeverHappen } from '@livestore/utils'
 import { pipe, ReadonlyArray, Schema, TreeFormatter } from '@livestore/utils/effect'
 import type { SqliteDsl } from 'effect-db-schema'
 
@@ -55,7 +56,7 @@ export const insertRow = <TColumns extends SqliteDsl.Columns>({
   tableName: string
   columns: TColumns
   values: ClientTypes.DecodedValuesForColumns<TColumns>
-  options: { orReplace: boolean }
+  options?: { orReplace: boolean }
 }): [string, BindValues] => {
   const keysStr = Object.keys(values).join(', ')
   const valuesStr = Object.keys(values)
@@ -63,7 +64,7 @@ export const insertRow = <TColumns extends SqliteDsl.Columns>({
     .join(', ')
 
   return [
-    sql`INSERT ${options.orReplace ? 'OR REPLACE' : ''} INTO ${tableName} (${keysStr}) VALUES (${valuesStr})`,
+    sql`INSERT ${options.orReplace ? 'OR REPLACE ' : ''}INTO ${tableName} (${keysStr}) VALUES (${valuesStr})`,
     makeBindValues({ columns, values }),
   ]
 }
@@ -263,7 +264,7 @@ export const makeBindValues = <TColumns extends SqliteDsl.Columns, TKeys extends
         if (columnDef.nullable === true && (value === null || value === undefined)) return null
         const res = Schema.encodeEither(columnDef.schema)(value)
         if (res._tag === 'Left') {
-          const parseErrorStr = TreeFormatter.formatError(res.left)
+          const parseErrorStr = TreeFormatter.formatErrorSync(res.left)
           const expectedSchemaStr = String(columnDef.schema.ast)
 
           console.error(
@@ -292,26 +293,24 @@ Value:`,
       // NOTE null/undefined values are handled via explicit SQL syntax and don't need to be provided as bind values
       .filter(([, value]) => skipNil !== true || (value !== null && value !== undefined))
       .flatMap(([columnName, value]: [string, any]) => {
+        const codec = codecMap[columnName] ?? shouldNeverHappen(`No codec found for column "${columnName}"`)
         // remap complex where-values with `op`
         if (typeof value === 'object' && value !== null && 'op' in value) {
           switch (value.op) {
             case 'in': {
-              return value.val.map((value: any, i: number) => [
-                `${variablePrefix}${columnName}_${i}`,
-                codecMap[columnName]!(value),
-              ])
+              return value.val.map((value: any, i: number) => [`${variablePrefix}${columnName}_${i}`, codec(value)])
             }
             case '=':
             case '>':
             case '<': {
-              return [[`${variablePrefix}${columnName}`, codecMap[columnName]!(value.val)]]
+              return [[`${variablePrefix}${columnName}`, codec(value.val)]]
             }
             default: {
               throw new Error(`Unknown op: ${value.op}`)
             }
           }
         } else {
-          return [[`${variablePrefix}${columnName}`, codecMap[columnName]!(value)]]
+          return [[`${variablePrefix}${columnName}`, codec(value)]]
         }
       }),
     Object.fromEntries,

package/src/sync/index.ts

@@ -0,0 +1 @@
+export * from './sync.js'

package/src/sync/sync.ts

@@ -0,0 +1,14 @@
+import { type Effect, Schema, type Stream, type SubscriptionRef } from '@livestore/utils/effect'
+
+import type { MutationEvent } from '../schema/mutations.js'
+
+export type SyncImpl = {
+  pull: (cursor: string | undefined) => Stream.Stream<MutationEvent.AnyEncoded, IsOfflineError | InvalidPullError>
+  push: (mutationEvent: MutationEvent.AnyEncoded) => Effect.Effect<void, IsOfflineError | InvalidPushError>
+  pushes: Stream.Stream<MutationEvent.AnyEncoded>
+  isConnected: SubscriptionRef.SubscriptionRef<boolean>
+}
+
+export class IsOfflineError extends Schema.TaggedError<IsOfflineError>()('IsOfflineError', {}) {}
+export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('InvalidPushError', {}) {}
+export class InvalidPullError extends Schema.TaggedError<InvalidPullError>()('InvalidPullError', {}) {}