@livestore/common 0.4.0 → 0.5.0-dev.1

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

@@ -1,8 +1,8 @@
-import { objectToString } from '@livestore/utils'
-
-import { Schema } from '@livestore/utils/effect'
+import { TestSchema } from 'effect/testing'
 import { describe, expect, expectTypeOf, it } from 'vitest'
 
+import { Schema, SchemaAST, SchemaTransformation } from '@livestore/utils/effect'
+
 import { State } from '../../mod.ts'
 
 describe('table function overloads', () => {
@@ -11,7 +11,7 @@ describe('table function overloads', () => {
       id: Schema.String,
       text: Schema.String,
       completed: Schema.Boolean,
-    }).annotations({ title: 'todos' })
+    }).annotate({ title: 'todos' })
 
     const todosTable = State.SQLite.table({
       schema: TodoSchema,
@@ -25,7 +25,7 @@ describe('table function overloads', () => {
       id: Schema.String,
       text: Schema.String,
       completed: Schema.Boolean,
-    }).annotations({ identifier: 'TodoItem' })
+    }).annotate({ identifier: 'TodoItem' })
 
     const todosTable = State.SQLite.table({ schema: TodoSchema })
 
@@ -37,7 +37,7 @@ describe('table function overloads', () => {
       id: Schema.String,
       text: Schema.String,
       completed: Schema.Boolean,
-    }).annotations({
+    }).annotate({
       title: 'todos',
       identifier: 'TodoItem',
     })
@@ -59,7 +59,7 @@ describe('table function overloads', () => {
     )
   })
 
-  it('should work with columns parameter', () => {
+  it('should work with columns parameter', async () => {
     const todosTable = State.SQLite.table({
       name: 'todos',
       columns: {
@@ -74,7 +74,6 @@ describe('table function overloads', () => {
       },
     })
 
-    expect((todosTable.rowSchema as any).fields.completed.toString()).toMatchInlineSnapshot(`"(number <-> boolean)"`)
     expect(todosTable.sqliteDef.name).toBe('todos')
     expect(todosTable.sqliteDef.columns).toHaveProperty('id')
     expect(todosTable.sqliteDef.columns).toHaveProperty('text')
@@ -82,15 +81,42 @@ describe('table function overloads', () => {
     expect(todosTable.sqliteDef.columns).toHaveProperty('optionalComplex')
 
     expect(todosTable.sqliteDef.columns.optionalBoolean.nullable).toBe(true)
-    expect(objectToString(todosTable.sqliteDef.columns.optionalBoolean.schema)).toBe('(number <-> boolean) | null')
-    expect((todosTable.rowSchema as any).fields.optionalBoolean.toString()).toBe('(number <-> boolean) | null')
+    expect(Schema.encodeSync(todosTable.sqliteDef.columns.optionalBoolean.schema)(false)).toBe(0)
 
     expect(todosTable.sqliteDef.columns.optionalComplex.nullable).toBe(true)
-    expect(objectToString(todosTable.sqliteDef.columns.optionalComplex.schema)).toBe(
-      '(parseJson <-> { readonly color: string } | undefined) | null',
+
+    const asserts = new TestSchema.Asserts(todosTable.rowSchema)
+    await asserts.decoding().succeed(
+      {
+        id: 'todo-1',
+        text: 'Buy milk',
+        completed: 1,
+        optionalBoolean: null,
+        optionalComplex: JSON.stringify({ color: 'red' }),
+      },
+      {
+        id: 'todo-1',
+        text: 'Buy milk',
+        completed: true,
+        optionalBoolean: null,
+        optionalComplex: { color: 'red' },
+      },
     )
-    expect((todosTable.rowSchema as any).fields.optionalComplex.toString()).toBe(
-      '(parseJson <-> { readonly color: string } | undefined) | null',
+    await asserts.decoding().succeed(
+      {
+        id: 'todo-1',
+        text: 'Buy milk',
+        completed: 0,
+        optionalBoolean: null,
+        optionalComplex: null,
+      },
+      {
+        id: 'todo-1',
+        text: 'Buy milk',
+        completed: false,
+        optionalBoolean: null,
+        optionalComplex: null,
+      },
     )
   })
 
@@ -156,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,
@@ -197,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),
@@ -205,32 +297,33 @@ describe('table function overloads', () => {
       contactEmail: Schema.String.pipe(State.SQLite.withUnique),
     })
 
-    const Nested = Schema.transform(
-      Flat,
-      Schema.Struct({
-        id: Schema.String,
-        contact: Schema.Struct({
-          firstName: Schema.String,
-          lastName: Schema.String,
-          email: Schema.String,
-        }),
-      }),
-      {
-        decode: ({ id, contactFirstName, contactLastName, contactEmail }) => ({
-          id,
-          contact: {
-            firstName: contactFirstName,
-            lastName: contactLastName,
-            email: contactEmail,
-          },
+    const Nested = Flat.pipe(
+      Schema.decodeTo(
+        Schema.Struct({
+          id: Schema.String,
+          contact: Schema.Struct({
+            firstName: Schema.String,
+            lastName: Schema.String,
+            email: Schema.String,
+          }),
         }),
-        encode: ({ id, contact }) => ({
-          id,
-          contactFirstName: contact.firstName,
-          contactLastName: contact.lastName,
-          contactEmail: contact.email,
+        SchemaTransformation.transform({
+          decode: ({ id, contactFirstName, contactLastName, contactEmail }) => ({
+            id,
+            contact: {
+              firstName: contactFirstName,
+              lastName: contactLastName,
+              email: contactEmail,
+            },
+          }),
+          encode: ({ id, contact }) => ({
+            id,
+            contactFirstName: contact.firstName,
+            contactLastName: contact.lastName,
+            contactEmail: contact.email,
+          }),
         }),
-      },
+      ),
     )
 
     const contactsTable = State.SQLite.table({
@@ -266,13 +359,13 @@ describe('table function overloads', () => {
     expect(todosTable.sqliteDef.name).toBe('TodoItem')
   })
 
-  it('should properly infer types from schema', () => {
+  it('should properly infer types from schema', async () => {
     const UserSchema = Schema.Struct({
       id: Schema.String,
       name: Schema.String,
       age: Schema.Int,
       active: Schema.Boolean,
-      metadata: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Unknown })),
+      metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
     })
 
     const userTable = State.SQLite.table({
@@ -297,13 +390,6 @@ describe('table function overloads', () => {
     type ActiveColumn = typeof userTable.sqliteDef.columns.active
     type MetadataColumn = typeof userTable.sqliteDef.columns.metadata
 
-    // Should derive proper column schema
-    expect((userTable.rowSchema as any).fields.age.toString()).toMatchInlineSnapshot(`"Int"`)
-    expect((userTable.rowSchema as any).fields.active.toString()).toMatchInlineSnapshot(`"(number <-> boolean)"`)
-    expect((userTable.rowSchema as any).fields.metadata.toString()).toMatchInlineSnapshot(
-      `"(parseJson <-> { readonly [x: string]: unknown }) | null"`,
-    )
-
     // These should compile without errors
     const _idCheck: IdColumn['schema']['Type'] = 'string'
     const _nameCheck: NameColumn['schema']['Type'] = 'string'
@@ -318,6 +404,28 @@ describe('table function overloads', () => {
     expect(userTable.sqliteDef.columns.active.columnType).toBe('integer')
     expect(userTable.sqliteDef.columns.metadata.columnType).toBe('text')
     expect(userTable.sqliteDef.columns.metadata.nullable).toBe(true)
+
+    const asserts = new TestSchema.Asserts(userTable.rowSchema)
+    await asserts.decoding().succeed(
+      {
+        id: 'test-id',
+        name: 'John',
+        age: 30,
+        active: 1,
+        metadata: JSON.stringify({ key1: 'value1', key2: 123 }),
+      },
+      {
+        id: 'test-id',
+        name: 'John',
+        age: 30,
+        active: true,
+        metadata: { key1: 'value1', key2: 123 },
+      },
+    )
+    const activeAsserts = new TestSchema.Asserts(userTable.sqliteDef.columns.active.schema)
+    const metadataAsserts = new TestSchema.Asserts(userTable.sqliteDef.columns.metadata.schema)
+    await activeAsserts.decoding().succeed(0, false)
+    await metadataAsserts.decoding().succeed(null)
   })
 
   it('should allow omitting nullable fields in insert()', () => {
@@ -347,41 +455,117 @@ describe('table function overloads', () => {
       .toBeCallableWith({ id: '1', undefined: undefined, null: null, undefinedOrString: undefined })
       .toBeCallableWith({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string' })
       .toBeCallableWith({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string', nullOrString: null })
-      .toBeCallableWith({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string', nullOrString: 'string' })
-      .toBeCallableWith({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string', nullOrString: 'string', optionalString: 'string' })
-      .toBeCallableWith({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string', nullOrString: 'string', optionalString: 'string', optionalNullOrString: null })
-      .toBeCallableWith({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string', nullOrString: 'string', optionalString: 'string', optionalNullOrString: 'string' })
+      .toBeCallableWith({
+        id: '1',
+        undefined: undefined,
+        null: null,
+        undefinedOrString: 'string',
+        nullOrString: 'string',
+      })
+      .toBeCallableWith({
+        id: '1',
+        undefined: undefined,
+        null: null,
+        undefinedOrString: 'string',
+        nullOrString: 'string',
+        optionalString: 'string',
+      })
+      .toBeCallableWith({
+        id: '1',
+        undefined: undefined,
+        null: null,
+        undefinedOrString: 'string',
+        nullOrString: 'string',
+        optionalString: 'string',
+        optionalNullOrString: null,
+      })
+      .toBeCallableWith({
+        id: '1',
+        undefined: undefined,
+        null: null,
+        undefinedOrString: 'string',
+        nullOrString: 'string',
+        optionalString: 'string',
+        optionalNullOrString: 'string',
+      })
 
     expect(() => usersTable.insert({ id: '1' }).asSql()).not.toThrow()
     expect(() => usersTable.insert({ id: '1', undefined: undefined }).asSql()).not.toThrow()
     expect(() => usersTable.insert({ id: '1', undefined: undefined, null: null }).asSql()).not.toThrow()
-    expect(() => usersTable.insert({ id: '1', undefined: undefined, null: null, undefinedOrString: undefined }).asSql()).not.toThrow()
-    expect(() => usersTable.insert({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string' }).asSql()).not.toThrow()
-    expect(() => usersTable.insert({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string', nullOrString: null }).asSql()).not.toThrow()
-    expect(() => usersTable.insert({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string', nullOrString: 'string' }).asSql()).not.toThrow()
-    expect(() => usersTable.insert({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string', nullOrString: 'string', optionalString: 'string' }).asSql()).not.toThrow()
-    expect(() => usersTable.insert({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string', nullOrString: 'string', optionalString: 'string', optionalNullOrString: null }).asSql()).not.toThrow()
-    expect(() => usersTable.insert({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string', nullOrString: 'string', optionalString: 'string', optionalNullOrString: 'string' }).asSql()).not.toThrow()
+    expect(() =>
+      usersTable.insert({ id: '1', undefined: undefined, null: null, undefinedOrString: undefined }).asSql(),
+    ).not.toThrow()
+    expect(() =>
+      usersTable.insert({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string' }).asSql(),
+    ).not.toThrow()
+    expect(() =>
+      usersTable
+        .insert({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string', nullOrString: null })
+        .asSql(),
+    ).not.toThrow()
+    expect(() =>
+      usersTable
+        .insert({ id: '1', undefined: undefined, null: null, undefinedOrString: 'string', nullOrString: 'string' })
+        .asSql(),
+    ).not.toThrow()
+    expect(() =>
+      usersTable
+        .insert({
+          id: '1',
+          undefined: undefined,
+          null: null,
+          undefinedOrString: 'string',
+          nullOrString: 'string',
+          optionalString: 'string',
+        })
+        .asSql(),
+    ).not.toThrow()
+    expect(() =>
+      usersTable
+        .insert({
+          id: '1',
+          undefined: undefined,
+          null: null,
+          undefinedOrString: 'string',
+          nullOrString: 'string',
+          optionalString: 'string',
+          optionalNullOrString: null,
+        })
+        .asSql(),
+    ).not.toThrow()
+    expect(() =>
+      usersTable
+        .insert({
+          id: '1',
+          undefined: undefined,
+          null: null,
+          undefinedOrString: 'string',
+          nullOrString: 'string',
+          optionalString: 'string',
+          optionalNullOrString: 'string',
+        })
+        .asSql(),
+    ).not.toThrow()
   })
 
   it('supports discriminated unions with parsed JSON payloads', () => {
     const CircleDataSchema = Schema.Struct({
-      radius: Schema.Number,
+      radius: Schema.Finite,
     })
     const CircleSchema = Schema.Struct({
       kind: Schema.Literal('circle'),
-      data: Schema.parseJson(CircleDataSchema),
+      data: Schema.fromJsonString(CircleDataSchema),
     })
 
     const SquareDataSchema = Schema.Struct({
-      sideLength: Schema.Number,
+      sideLength: Schema.Finite,
     })
     const SquareSchema = Schema.Struct({
       kind: Schema.Literal('square'),
-      data: Schema.parseJson(SquareDataSchema),
+      data: Schema.fromJsonString(SquareDataSchema),
     })
 
-    const ShapeSchema = Schema.Union(CircleSchema, SquareSchema)
+    const ShapeSchema = Schema.Union([CircleSchema, SquareSchema])
 
     const shapes = State.SQLite.table({
       name: 'shapes',
@@ -389,9 +573,7 @@ describe('table function overloads', () => {
     })
 
     expect(shapes.sqliteDef.columns.kind.columnType).toBe('text')
-
-    const kindSchema = objectToString(shapes.sqliteDef.columns.kind.schema)
-    expect(kindSchema).toContain('"circle" | "square"')
+    expect(SchemaAST.isUnion(Schema.toEncoded(shapes.sqliteDef.columns.kind.schema).ast)).toBe(true)
 
     expect(() =>
       shapes
@@ -411,4 +593,26 @@ describe('table function overloads', () => {
         .asSql(),
     ).not.toThrow()
   })
+
+  it('treats optional common union fields as nullable columns', () => {
+    const StateSchema = Schema.Union([
+      Schema.Struct({
+        kind: Schema.Literal('empty'),
+        note: Schema.optional(Schema.String),
+      }),
+      Schema.Struct({
+        kind: Schema.Literal('ready'),
+        note: Schema.optional(Schema.String),
+      }),
+    ])
+
+    const states = State.SQLite.table({
+      name: 'states',
+      schema: StateSchema,
+    })
+
+    expect(states.sqliteDef.columns.kind.columnType).toBe('text')
+    expect(states.sqliteDef.columns.note.columnType).toBe('text')
+    expect(states.sqliteDef.columns.note.nullable).toBe(true)
+  })
 })