@livestore/common 0.5.0-dev.0 → 0.5.0-dev.1

package/src/schema/state/sqlite/table-def.test.ts

@@ -182,6 +182,54 @@ describe('table function overloads', () => {
     expect(userTable.sqliteDef.columns.email.nullable).toBe(true)
   })
 
+  it('keeps a date codec so the column round-trips through its encoded form', () => {
+    const StampSchema = Schema.Struct({
+      id: Schema.String.pipe(State.SQLite.withPrimaryKey),
+      createdAt: Schema.DateFromString,
+      seenAt: Schema.DateFromMillis,
+      bornAt: Schema.Date,
+      deletedAt: Schema.NullOr(Schema.DateFromString),
+      archivedAt: Schema.optional(Schema.DateFromString),
+    })
+
+    const { columns } = State.SQLite.table({ name: 'stamps', schema: StampSchema }).sqliteDef
+    const date = new Date('2026-01-02T03:04:05.678Z')
+    const roundTrip = (column: { schema: Schema.Codec<any, any> }, value: unknown) =>
+      Schema.decodeUnknownSync(column.schema)(Schema.encodeUnknownSync(column.schema)(value))
+
+    expect(columns.createdAt.columnType).toBe('text')
+    expect(Schema.encodeUnknownSync(columns.createdAt.schema)(date)).toBe(date.toISOString())
+    expect(roundTrip(columns.createdAt, date)).toEqual(date)
+
+    expect(columns.seenAt.columnType).toBe('integer')
+    expect(Schema.encodeUnknownSync(columns.seenAt.schema)(date)).toBe(date.getTime())
+    expect(roundTrip(columns.seenAt, date)).toEqual(date)
+
+    expect(columns.bornAt.columnType).toBe('text')
+    expect(Schema.encodeUnknownSync(columns.bornAt.schema)(date)).toBe(date.toISOString())
+    expect(roundTrip(columns.bornAt, date)).toEqual(date)
+
+    expect(columns.deletedAt.nullable).toBe(true)
+    expect(roundTrip(columns.deletedAt, date)).toEqual(date)
+    expect(roundTrip(columns.deletedAt, null)).toBeNull()
+
+    expect(columns.archivedAt.nullable).toBe(true)
+    expect(roundTrip(columns.archivedAt, date)).toEqual(date)
+  })
+
+  it('stores a codec field in its encoded form, like getColumnDefForSchema does', () => {
+    const CounterSchema = Schema.Struct({
+      id: Schema.String,
+      count: Schema.FiniteFromString,
+    })
+
+    const { columns } = State.SQLite.table({ name: 'counters', schema: CounterSchema }).sqliteDef
+
+    expect(columns.count.columnType).toBe('text')
+    expect(Schema.encodeUnknownSync(columns.count.schema)(42)).toBe('42')
+    expect(Schema.decodeSync(columns.count.schema)('42')).toBe(42)
+  })
+
   it('should handle Schema.Int as integer column', () => {
     const CounterSchema = Schema.Struct({
       id: Schema.String,
@@ -223,6 +271,24 @@ describe('table function overloads', () => {
     expect(userTable.sqliteDef.columns.age.columnType).toBe('integer')
   })
 
+  it('preserves Date field codecs in Schema.Class tables', () => {
+    class Stamp extends Schema.Class<Stamp>('Stamp')({
+      id: Schema.String,
+      createdAt: Schema.DateFromString,
+      seenAt: Schema.DateFromMillis,
+    }) {}
+
+    const { columns } = State.SQLite.table({ name: 'stamps', schema: Stamp }).sqliteDef
+    const date = new Date('2026-01-02T03:04:05.678Z')
+
+    expect(columns.createdAt.columnType).toBe('text')
+    expect(Schema.decodeSync(columns.createdAt.schema)(date.toISOString())).toEqual(date)
+    expect(Schema.encodeUnknownSync(columns.createdAt.schema)(date)).toBe(date.toISOString())
+    expect(columns.seenAt.columnType).toBe('integer')
+    expect(Schema.decodeSync(columns.seenAt.schema)(date.getTime())).toEqual(date)
+    expect(Schema.encodeUnknownSync(columns.seenAt.schema)(date)).toBe(date.getTime())
+  })
+
   it('should support schemas that transform flat columns into nested types', () => {
     const Flat = Schema.Struct({
       id: Schema.String.pipe(State.SQLite.withPrimaryKey),

package/src/schema/state/sqlite/table-def.ts

@@ -265,26 +265,42 @@ export function table<
   return tableDef as any
 }
 
+/**
+ * The encoded side of the schema decides which columns exist (a transformation may flatten a nested
+ * type into columns). Where the schema itself declares a property of the same name, that property's
+ * own AST becomes the column schema: it still carries the field's encoding, so a codec such as
+ * `Schema.DateFromString` or `Schema.DateFromMillis` stores its encoded form and decodes back to
+ * its type. Substituting the type-side AST instead would strip that encoding and leave a `Date`
+ * with nothing SQLite can store natively, which is how date columns ended up JSON-encoded and
+ * unreadable.
+ */
 const getSqlitePropertySignatures = (schema: Schema.Top): ReadonlyArray<SchemaAST.PropertySignature> => {
   const encodedPropertySignatures = getPropertySignatures(SchemaAST.toEncoded(schema.ast))
-  const typePropertySignatures = getPropertySignatures(SchemaAST.toType(schema.ast))
+  const ownPropertySignatures = getPropertySignatures(schema.ast)
 
   return encodedPropertySignatures.map((encodedPropertySignature) => {
-    const typePropertySignature = typePropertySignatures.find(
+    const ownPropertySignature = ownPropertySignatures.find(
       (propertySignature) => propertySignature.name === encodedPropertySignature.name,
     )
 
-    if (typePropertySignature === undefined || hasLiveStoreSqliteAnnotation(encodedPropertySignature.type) === true) {
+    if (ownPropertySignature === undefined || hasLiveStoreSqliteAnnotation(encodedPropertySignature.type) === true) {
       return encodedPropertySignature
     }
 
-    return new SchemaAST.PropertySignature(encodedPropertySignature.name, typePropertySignature.type)
+    return ownPropertySignature
   })
 }
 
 const getPropertySignatures = (ast: SchemaAST.AST): ReadonlyArray<SchemaAST.PropertySignature> => {
   if (SchemaAST.isObjects(ast) === true) return ast.propertySignatures
 
+  // Class declarations encode through their fields object. Inspect that first
+  // link before toEncoded strips the individual field codecs.
+  if (SchemaAST.isDeclaration(ast) === true) {
+    const fieldsAst = ast.encoding?.[0]?.to
+    if (fieldsAst !== undefined) return getPropertySignatures(fieldsAst)
+  }
+
   if (SchemaAST.isUnion(ast) === true) {
     const members = ast.types.map(getPropertySignatures)
     const [head, ...tail] = members
@@ -314,7 +330,7 @@ const getPropertySignatures = (ast: SchemaAST.AST): ReadonlyArray<SchemaAST.Prop
       const keyContext = hasOptionalMember === true ? new SchemaAST.Context(true, false) : undefined
       const union = new SchemaAST.Union(
         propertySignatures.map((memberPropertySignature) => memberPropertySignature.type),
-        ast.mode,
+        ast.options,
         undefined,
         undefined,
         undefined,

package/src/schema-management/__tests__/migrations-autoincrement-quoting.test.ts

@@ -2,13 +2,16 @@ import { describe, expect, it } from 'vitest'
 
 import { Effect, Option, Schema } from '@livestore/utils/effect'
 
+import { fingerprint } from '../../schema/state/sqlite/db-schema/ast/fingerprint.ts'
 import { SqliteAst } from '../../schema/state/sqlite/db-schema/mod.ts'
+import { schemaMetaTable } from '../../schema/state/sqlite/system-tables/state-tables.ts'
 import type { PreparedStatement, SqliteDb } from '../../sqlite-types.ts'
 import type { PreparedBindValues } from '../../util.ts'
 import { migrateTable } from '../migrations.ts'
 
 const makeStubDb = () => {
   const executed: string[] = []
+  const bindings: Array<PreparedBindValues | undefined> = []
 
   const db: SqliteDb = {
     _tag: 'SqliteDb',
@@ -16,8 +19,9 @@ const makeStubDb = () => {
     debug: { head: 0 as any },
     prepare: (queryStr: string): PreparedStatement => ({
       sql: queryStr,
-      execute: (_bind: PreparedBindValues | undefined) => {
+      execute: (bind: PreparedBindValues | undefined) => {
         executed.push(queryStr)
+        bindings.push(bind)
       },
       select: <T>(_bind: PreparedBindValues | undefined) => [] as unknown as ReadonlyArray<T>,
       finalize: () => {},
@@ -32,7 +36,7 @@ const makeStubDb = () => {
     makeChangeset: () => ({ invert: () => ({ invert: () => ({}) as any, apply: () => {} }) as any, apply: () => {} }),
   }
 
-  return { db, executed }
+  return { db, executed, bindings }
 }
 
 describe('migrateTable - quoting and autoincrement', () => {
@@ -85,4 +89,31 @@ describe('migrateTable - quoting and autoincrement', () => {
     expect(createStmt!).not.toContain("PRIMARY KEY ('id')")
     expect(createStmt!).not.toMatch(/'todos'|'id'|'text'/)
   })
+
+  it('persists full textual table fingerprints', () => {
+    const { db, bindings } = makeStubDb()
+    const table = SqliteAst.table(
+      'todos',
+      [
+        SqliteAst.column({
+          name: 'id',
+          type: { _tag: 'text' },
+          nullable: false,
+          primaryKey: true,
+          autoIncrement: false,
+          default: Option.none(),
+          schema: Schema.String,
+        }),
+      ],
+      [],
+    )
+
+    migrateTable({ db, tableAst: table, behaviour: 'create-if-not-exists' }).pipe(Effect.runSync)
+
+    const schemaMetaBinding = bindings.find(
+      (binding) => binding !== undefined && Array.isArray(binding) === false && '$schemaHash' in binding,
+    )
+    expect(schemaMetaBinding).toMatchObject({ $schemaHash: fingerprint(table) })
+    expect(schemaMetaTable.sqliteDef.ast.columns.find((column) => column.name === 'schemaHash')?.type._tag).toBe('text')
+  })
 })

package/src/schema-management/migrations.ts

@@ -8,7 +8,7 @@
  * - EVENTLOG TABLES (NEVER modify): Changes cause data loss - need manual versioning!
  *
  * How it works:
- * 1. Each table's schema is hashed using SqliteAst.hash()
+ * 1. Each table's schema is fingerprinted
  * 2. Hashes are stored in SCHEMA_META_TABLE after successful migrations
  * 3. On app start, current schema hashes are compared with stored hashes
  * 4. Mismatches trigger migrations:
@@ -37,7 +37,8 @@ import type { MigrationsReport, MigrationsReportEntry } from '../defs.ts'
 import type { UnknownError } from '../errors.ts'
 import type { LiveStoreSchema } from '../schema/mod.ts'
 import { makeColumnSpec } from '../schema/state/sqlite/column-spec.ts'
-import { SqliteAst } from '../schema/state/sqlite/db-schema/mod.ts'
+import { fingerprint } from '../schema/state/sqlite/db-schema/ast/fingerprint.ts'
+import type { SqliteAst } from '../schema/state/sqlite/db-schema/mod.ts'
 import type { SchemaEventDefsMetaRow, SchemaMetaRow } from '../schema/state/sqlite/system-tables/state-tables.ts'
 import {
   isStateSystemTable,
@@ -114,14 +115,14 @@ export const migrateDb = ({
       ...Array.from(schema.state.sqlite.tables.values()).filter((_) => !isStateSystemTable(_.sqliteDef.name)),
     ]
 
-    const tablesToMigrate = new Set<{ tableAst: SqliteAst.Table; schemaHash: number }>()
+    const tablesToMigrate = new Set<{ tableAst: SqliteAst.Table; schemaHash: string }>()
 
     const migrationsReportEntries: MigrationsReportEntry[] = []
     for (const tableDef of tableDefs) {
       const tableAst = tableDef.sqliteDef.ast
       const tableName = tableAst.name
       const dbSchemaHash = dbSchemaHashByTable[tableName]
-      const schemaHash = SqliteAst.hash(tableAst)
+      const schemaHash = fingerprint(tableAst)
 
       if (schemaHash !== dbSchemaHash) {
         tablesToMigrate.add({ tableAst, schemaHash })
@@ -151,13 +152,13 @@ export const migrateDb = ({
 export const migrateTable = ({
   db,
   tableAst,
-  schemaHash = SqliteAst.hash(tableAst),
+  schemaHash = fingerprint(tableAst),
   behaviour,
   skipMetaTable = false,
 }: {
   db: SqliteDb
   tableAst: SqliteAst.Table
-  schemaHash?: number
+  schemaHash?: string
   behaviour: 'drop-and-recreate' | 'create-if-not-exists'
   skipMetaTable?: boolean
 }) =>

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

@@ -298,7 +298,7 @@ Error: ${parseErrorStr}
 Value:`,
             value,
           )
-          // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint for SQL decode errors
+          // oxlint-disable-next-line no-debugger -- intentional breakpoint for SQL decode errors
           debugger
           throw res.failure
         } else {

package/src/util.ts

@@ -19,6 +19,7 @@ export const SqliteReal = Schema.Number
 
 export const SqlValueSchema = Schema.Union([
   Schema.String,
+  // @effect-diagnostics-next-line schemaNumber:off -- SQLite REAL permits Infinity/NaN; SqliteReal is the documented domain carve-out
   SqliteReal,
   Schema.Uint8Array as any as Schema.Codec<Uint8Array<ArrayBuffer>>,
   Schema.Null,

package/dist/schema/state/sqlite/db-schema/hash.d.ts

@@ -1,2 +0,0 @@
-export declare const hashCode: (str: string) => number;
-//# sourceMappingURL=hash.d.ts.map

package/dist/schema/state/sqlite/db-schema/hash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../../../src/schema/state/sqlite/db-schema/hash.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,WAWnC,CAAA"}

package/dist/schema/state/sqlite/db-schema/hash.js

@@ -1,15 +0,0 @@
-// Based on https://stackoverflow.com/a/7616484
-export const hashCode = (str) => {
-    let hash = 0;
-    let i;
-    let chr;
-    if (str.length === 0)
-        return hash;
-    for (i = 0; i < str.length; i++) {
-        chr = str.charCodeAt(i);
-        hash = (hash << 5) - hash + chr;
-        hash = Math.trunc(hash); // Convert to 32bit integer
-    }
-    return hash;
-};
-//# sourceMappingURL=hash.js.map

package/dist/schema/state/sqlite/db-schema/hash.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash.js","sourceRoot":"","sources":["../../../../../src/schema/state/sqlite/db-schema/hash.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,GAAW,EAAE,EAAE;IACtC,IAAI,IAAI,GAAG,CAAC,CAAA;IACZ,IAAI,CAAS,CAAA;IACb,IAAI,GAAW,CAAA;IACf,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IACjC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAChC,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAA;QACvB,IAAI,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,GAAG,GAAG,CAAA;QAC/B,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA,CAAC,2BAA2B;IACrD,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC,CAAA"}

package/src/schema/state/sqlite/db-schema/hash.ts

@@ -1,13 +0,0 @@
-// Based on https://stackoverflow.com/a/7616484
-export const hashCode = (str: string) => {
-  let hash = 0
-  let i: number
-  let chr: number
-  if (str.length === 0) return hash
-  for (i = 0; i < str.length; i++) {
-    chr = str.charCodeAt(i)
-    hash = (hash << 5) - hash + chr
-    hash = Math.trunc(hash) // Convert to 32bit integer
-  }
-  return hash
-}