@livestore/common 0.4.0 → 0.5.0-dev.1

package/src/schema/state/sqlite/query-builder/impl.ts

@@ -1,6 +1,5 @@
-/** biome-ignore-all lint/complexity/noArguments: using arguments is fine here */
 import { casesHandled, shouldNeverHappen } from '@livestore/utils'
-import { Match, Option, Predicate, Schema } from '@livestore/utils/effect'
+import { Match, Option, Predicate, Schema, Struct } from '@livestore/utils/effect'
 
 import type { TableDefBase } from '../table-def.ts'
 import type { QueryBuilder, QueryBuilderAst } from './api.ts'
@@ -22,7 +21,7 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
         const [col] = params as any as [string]
         return makeQueryBuilder(tableDef, {
           ...ast,
-          resultSchemaSingle: ast.resultSchemaSingle.pipe(Schema.pluck(col)),
+          resultSchemaSingle: ast.tableDef.rowSchema.pipe(Schema.pluck(col)),
           select: { columns: [col] },
         })
       }
@@ -34,7 +33,7 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
       return makeQueryBuilder(tableDef, {
         ...ast,
         resultSchemaSingle:
-          columns.length === 0 ? ast.resultSchemaSingle : ast.resultSchemaSingle.pipe(Schema.pick(...columns)),
+          columns.length === 0 ? ast.resultSchemaSingle : ast.tableDef.rowSchema.mapFields(Struct.pick(columns)),
         select: { columns },
       }) as any
     },
@@ -48,8 +47,8 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
           .filter(([, value]) => value !== undefined)
           .map<QueryBuilderAst.Where>(([col, value]) =>
             Predicate.hasProperty(value, 'op') === true && Predicate.hasProperty(value, 'value') === true
-              // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- where clause construction; shape validated at runtime
-              ? ({ col, op: value.op, value: value.value } as any)
+              ? // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- where clause construction; shape validated at runtime
+                ({ col, op: value.op, value: value.value } as any)
               : { col, op: '=', value },
           )
 
@@ -125,14 +124,19 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
       return makeQueryBuilder(tableDef, { ...ast, offset: Option.some(offset) })
     },
     count: () => {
-      if (isRowQuery(ast) === true || ast._tag === 'InsertQuery' || ast._tag === 'UpdateQuery' || ast._tag === 'DeleteQuery')
+      if (
+        isRowQuery(ast) === true ||
+        ast._tag === 'InsertQuery' ||
+        ast._tag === 'UpdateQuery' ||
+        ast._tag === 'DeleteQuery'
+      )
         return invalidQueryBuilder()
 
       return makeQueryBuilder(tableDef, {
         _tag: 'CountQuery',
         tableDef,
         where: ast.where,
-        resultSchema: Schema.Struct({ count: Schema.Number }).pipe(
+        resultSchema: Schema.Struct({ count: Schema.Finite }).pipe(
           Schema.pluck('count'),
           Schema.Array,
           Schema.headOrElse(),
@@ -223,7 +227,7 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
       return makeQueryBuilder(tableDef, {
         ...ast,
         returning: columns,
-        resultSchema: tableDef.rowSchema.pipe(Schema.pick(...columns), Schema.Array),
+        resultSchema: tableDef.rowSchema.mapFields(Struct.pick(columns)).pipe(Schema.Array),
       }) as any
     },
 
@@ -316,7 +320,7 @@ export const invalidQueryBuilder = (msg?: string) => {
   return shouldNeverHappen(`Invalid query builder${msg !== undefined ? `: ${msg}` : ''}`)
 }
 
-export const getResultSchema = (qb: QueryBuilder<any, any, any>): Schema.Schema<any> => {
+export const getResultSchema = (qb: QueryBuilder<any, any, any>) => {
   const queryAst = qb[QueryBuilderAstSymbol]
   switch (queryAst._tag) {
     case 'SelectQuery': {
@@ -331,13 +335,13 @@ export const getResultSchema = (qb: QueryBuilder<any, any, any>): Schema.Schema<
         return arraySchema.pipe(Schema.headOrElse())
       } else {
         const fallbackValue = queryAst.pickFirst.fallback()
-        return Schema.Union(arraySchema, Schema.Tuple(Schema.Literal(fallbackValue))).pipe(
+        return Schema.Array(Schema.Union([queryAst.resultSchemaSingle, Schema.Literal(fallbackValue)])).pipe(
           Schema.headOrElse(() => fallbackValue),
         )
       }
     }
     case 'CountQuery': {
-      return Schema.Struct({ count: Schema.Number }).pipe(Schema.pluck('count'), Schema.Array, Schema.headOrElse())
+      return Schema.Struct({ count: Schema.Finite }).pipe(Schema.pluck('count'), Schema.Array, Schema.headOrElse())
     }
     case 'InsertQuery':
     case 'UpdateQuery':
@@ -345,16 +349,16 @@ export const getResultSchema = (qb: QueryBuilder<any, any, any>): Schema.Schema<
       // For write operations with RETURNING clause, we need to return the appropriate schema
       if (queryAst.returning !== undefined && queryAst.returning.length > 0) {
         // Create a schema for the returned columns
-        return queryAst.tableDef.rowSchema.pipe(Schema.pick(...queryAst.returning), Schema.Array)
+        return queryAst.tableDef.rowSchema.mapFields(Struct.pick(queryAst.returning)).pipe(Schema.Array)
       }
 
       // For write operations without RETURNING, the result is the number of affected rows
-      return Schema.Number
+      return Schema.Finite
     }
     case 'RowQuery': {
       return queryAst.tableDef.rowSchema.pipe(
         Schema.pluck('value'),
-        Schema.annotations({ title: `${queryAst.tableDef.sqliteDef.name}.value` }),
+        Schema.annotate({ title: `${queryAst.tableDef.sqliteDef.name}.value` }),
         Schema.Array,
         Schema.headOrElse(),
       )

package/src/schema/state/sqlite/schema-helpers.ts

@@ -52,6 +52,6 @@ export const getDefaultValuesDecoded = <TTableDef extends TableDefBase>(
       const defaultValue = column!.default.value
       const resolvedDefault = SqliteDsl.resolveColumnDefault(defaultValue)
 
-      return Schema.validateSync(column!.schema)(resolvedDefault)
+      return Schema.decodeSync(Schema.toType(column!.schema))(resolvedDefault)
     }),
   )

package/src/schema/state/sqlite/system-tables/eventlog-tables.ts

@@ -30,11 +30,11 @@ export const eventlogMetaTable = table({
     parentSeqNumRebaseGeneration: SqliteDsl.integer({}),
     /** Event definition name */
     name: SqliteDsl.text({}),
-    argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
+    argsJson: SqliteDsl.text({ schema: Schema.fromJsonString(Schema.Any) }),
     clientId: SqliteDsl.text({}),
     sessionId: SqliteDsl.text({}),
     schemaHash: SqliteDsl.integer({}),
-    syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
+    syncMetadataJson: SqliteDsl.text({ schema: Schema.fromJsonString(Schema.toCodecJson(Schema.Option(Schema.Json))) }),
   },
   indexes: [
     { columns: ['seqNumGlobal'], name: 'idx_eventlog_seqNumGlobal' },

package/src/schema/state/sqlite/system-tables/state-tables.ts

@@ -6,7 +6,7 @@ import { table } from '../table-def.ts'
  * STATE DATABASE SYSTEM TABLES
  *
  * ⚠️  SAFE TO CHANGE: State tables are automatically rebuilt from eventlog when schema changes.
- * No need to bump `liveStoreStorageFormatVersion` (uses hash-based migration via SqliteAst.hash()).
+ * No need to bump `liveStoreStorageFormatVersion` because state tables use fingerprint-based migration.
  */
 
 export const SCHEMA_META_TABLE = '__livestore_schema'
@@ -18,7 +18,7 @@ export const schemaMetaTable = table({
   name: SCHEMA_META_TABLE,
   columns: {
     tableName: SqliteDsl.text({ primaryKey: true }),
-    schemaHash: SqliteDsl.integer({ nullable: false }),
+    schemaHash: SqliteDsl.text({ nullable: false }),
     /** ISO date format */
     updatedAt: SqliteDsl.text({ nullable: false }),
   },
@@ -43,6 +43,37 @@ export const schemaEventDefsMetaTable = table({
 
 export type SchemaEventDefsMetaRow = typeof schemaEventDefsMetaTable.Type
 
+export const STATE_HEAD_META_TABLE = '__livestore_state_head'
+
+/**
+ * Single-row marker for the latest event sequence number reflected by the state DB.
+ *
+ * @remarks
+ * This is separate from the session changeset table because confirmed changesets
+ * can be removed after they are no longer needed for rollback.
+ */
+export const stateHeadMetaTable = table({
+  name: STATE_HEAD_META_TABLE,
+  columns: {
+    id: SqliteDsl.integer({ primaryKey: true }),
+    seqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.Global.Schema }),
+    seqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.Client.Schema }),
+    seqNumRebaseGeneration: SqliteDsl.integer({}),
+  },
+})
+
+export type StateHeadMetaRow = typeof stateHeadMetaTable.Type
+
+export const REBUILD_META_TABLE = '__livestore_rebuild'
+
+/** Only a completed replay and successful migration hooks may insert the marker row. */
+export const rebuildMetaTable = table({
+  name: REBUILD_META_TABLE,
+  columns: {
+    id: SqliteDsl.integer({ primaryKey: true }),
+  },
+})
+
 /**
  * Table which stores SQLite changeset blobs which is used for rolling back
  * read-model state during rebasing.
@@ -64,6 +95,26 @@ export const sessionChangesetMetaTable = table({
 
 export type SessionChangesetMetaRow = typeof sessionChangesetMetaTable.Type
 
-export const stateSystemTables = [schemaMetaTable, schemaEventDefsMetaTable, sessionChangesetMetaTable] as const
+// TODO: Rename the physical table once legacy session changeset consumers have been migrated.
+export const MATERIALIZATION_JOURNAL_META_TABLE = SESSION_CHANGESET_META_TABLE
+
+/**
+ * Materialization journal used to roll back state database changes during rebasing.
+ *
+ * @remarks
+ * This aliases the legacy table definition until all session changeset consumers
+ * have adopted the journal service.
+ */
+export const materializationJournalMetaTable = sessionChangesetMetaTable
+
+export type MaterializationJournalMetaRow = SessionChangesetMetaRow
+
+export const stateSystemTables = [
+  schemaMetaTable,
+  schemaEventDefsMetaTable,
+  stateHeadMetaTable,
+  sessionChangesetMetaTable,
+  rebuildMetaTable,
+] as const
 
 export const isStateSystemTable = (tableName: string) => stateSystemTables.some((_) => _.sqliteDef.name === tableName)