@livestore/common 0.4.0 → 0.5.0-dev.1

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

@@ -1,7 +1,7 @@
+import { TestSchema } from 'effect/testing'
 import { assert, describe, expect, it } from 'vitest'
 
-import { Schema } from '@livestore/utils/effect'
-import { objectToString } from '@livestore/utils'
+import { Schema, SchemaAST, SchemaTransformation, Struct } from '@livestore/utils/effect'
 
 import * as State from '../mod.ts'
 import { withAutoIncrement, withColumnType, withDefault, withPrimaryKey, withUnique } from './column-annotations.ts'
@@ -14,7 +14,7 @@ describe('getColumnDefForSchema', () => {
     })
 
     it('should map Schema.Number to real column', () => {
-      const columnDef = State.SQLite.getColumnDefForSchema(Schema.Number)
+      const columnDef = State.SQLite.getColumnDefForSchema(Schema.Finite)
       expect(columnDef.columnType).toBe('real')
     })
 
@@ -26,15 +26,106 @@ describe('getColumnDefForSchema', () => {
     it('should map Schema.Date to text column', () => {
       const columnDef = State.SQLite.getColumnDefForSchema(Schema.Date)
       expect(columnDef.columnType).toBe('text')
-      expect(Schema.encodedSchema(columnDef.schema).toString()).toBe('string')
-      expect(Schema.typeSchema(columnDef.schema).toString()).toBe('Date')
+      const date = new Date('2026-01-02T03:04:05.678Z')
+      expect(Schema.encodeUnknownSync(columnDef.schema)(date)).toBe(date.toISOString())
+      expect(Schema.decodeSync(columnDef.schema)(date.toISOString())).toEqual(date)
+      expect(Schema.toEncoded(columnDef.schema).ast._tag).toBe('String')
+      expect(
+        SchemaAST.resolveAt<{ readonly id: string }>('representation')(Schema.toType(columnDef.schema).ast)?.id,
+      ).toBe('effect/schema/Date')
     })
 
-    it('should map Schema.DateFromNumber to integer column', () => {
-      const columnDef = State.SQLite.getColumnDefForSchema(Schema.DateFromNumber)
+    it('should map Schema.DateFromMillis to integer column', () => {
+      const columnDef = State.SQLite.getColumnDefForSchema(Schema.DateFromMillis)
       expect(columnDef.columnType).toBe('integer')
-      expect(Schema.encodedSchema(columnDef.schema).toString()).toBe('number')
-      expect(Schema.typeSchema(columnDef.schema).toString()).toBe('DateFromSelf')
+      expect(Schema.toEncoded(columnDef.schema).ast._tag).toBe('Number')
+      expect(
+        SchemaAST.resolveAt<{ readonly id: string }>('representation')(Schema.toType(columnDef.schema).ast)?.id,
+      ).toBe('effect/schema/Date')
+    })
+
+    it('should preserve the Date representation through checks', () => {
+      const schema = Schema.DateFromMillis.check(Schema.isGreaterThanDate(new Date(0)))
+
+      expect(State.SQLite.getColumnDefForSchema(schema).columnType).toBe('integer')
+    })
+
+    it('should preserve bare Date checks on encoding and decoding', () => {
+      const schema = Schema.Date.check(Schema.isGreaterThanDate(new Date(0)))
+      const columnDef = State.SQLite.getColumnDefForSchema(schema)
+      const date = new Date('2026-01-02T03:04:05.678Z')
+
+      expect(Schema.encodeUnknownSync(columnDef.schema)(date)).toBe(date.toISOString())
+      expect(Schema.decodeSync(columnDef.schema)(date.toISOString())).toEqual(date)
+      expect(() => Schema.encodeUnknownSync(columnDef.schema)(new Date(0))).toThrow()
+      expect(() => Schema.decodeSync(columnDef.schema)(new Date(0).toISOString())).toThrow()
+    })
+
+    it('should round-trip transformations with an encoded Date', () => {
+      const schema = Schema.Date.pipe(
+        Schema.decodeTo(
+          Schema.String,
+          SchemaTransformation.transform({
+            decode: (date) => date.toISOString(),
+            encode: (value) => new Date(value),
+          }),
+        ),
+      )
+      const columnDef = State.SQLite.getColumnDefForSchema(schema)
+      const value = '2026-01-02T03:04:05.678Z'
+
+      expect(columnDef.columnType).toBe('text')
+      expect(Schema.encodeUnknownSync(columnDef.schema)(value)).toBe(value)
+      expect(Schema.decodeSync(columnDef.schema)(value)).toBe(value)
+    })
+
+    it.each(['nullable', 'optional'] as const)(
+      'should round-trip %s transformations with an encoded Date',
+      (wrapper) => {
+        const schema = Schema.Date.pipe(
+          Schema.decodeTo(
+            Schema.String,
+            SchemaTransformation.transform({
+              decode: (date) => date.toISOString(),
+              encode: (value) => new Date(value),
+            }),
+          ),
+        )
+        const field = wrapper === 'nullable' ? Schema.NullOr(schema) : Schema.optional(schema)
+        const { columns } = State.SQLite.table({ name: 'stamps', schema: Schema.Struct({ value: field }) }).sqliteDef
+        const columnDef = columns.value
+        const value = '2026-01-02T03:04:05.678Z'
+
+        expect(columnDef.nullable).toBe(true)
+        expect(columnDef.columnType).toBe('text')
+        const encoded = Schema.encodeUnknownSync(columnDef.schema)(value)
+        expect(Schema.decodeSync(columnDef.schema)(encoded)).toBe(value)
+        expect(encoded).toBe(value)
+        expect(Schema.encodeUnknownSync(columnDef.schema)(null)).toBeNull()
+        expect(Schema.decodeSync(columnDef.schema)(null)).toBeNull()
+      },
+    )
+
+    it('should round-trip transformations with an encoded nullable Date', () => {
+      const schema = Schema.NullOr(Schema.Date).pipe(
+        Schema.decodeTo(
+          Schema.String,
+          SchemaTransformation.transform({
+            decode: (date) => (date === null ? 'none' : date.toISOString()),
+            encode: (value) => (value === 'none' ? null : new Date(value)),
+          }),
+        ),
+      )
+      const { columns } = State.SQLite.table({ name: 'stamps', schema: Schema.Struct({ value: schema }) }).sqliteDef
+      const columnDef = columns.value
+      const value = '2026-01-02T03:04:05.678Z'
+      const encoded = Schema.encodeUnknownSync(columnDef.schema)(value)
+
+      expect(Schema.decodeSync(columnDef.schema)(encoded)).toBe(value)
+      expect(encoded).toBe(value)
+      expect(columnDef.nullable).toBe(true)
+      expect(Schema.encodeUnknownSync(columnDef.schema)('none')).toBeNull()
+      expect(Schema.decodeSync(columnDef.schema)(null)).toBe('none')
     })
 
     it('should map Schema.BigInt to text column', () => {
@@ -47,17 +138,20 @@ describe('getColumnDefForSchema', () => {
     it('should map Schema.Int to integer column', () => {
       const columnDef = State.SQLite.getColumnDefForSchema(Schema.Int)
       expect(columnDef.columnType).toBe('integer')
+
+      const positiveInt = State.SQLite.getColumnDefForSchema(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)))
+      expect(positiveInt.columnType).toBe('integer')
     })
 
     it('should map string refinements to text column', () => {
       const refinements = [
         { schema: Schema.NonEmptyString, name: 'NonEmptyString' },
         { schema: Schema.Trim, name: 'Trim' },
-        { schema: Schema.UUID, name: 'UUID' },
-        { schema: Schema.ULID, name: 'ULID' },
-        { schema: Schema.String.pipe(Schema.minLength(5)), name: 'minLength' },
+        { schema: Schema.String.check(Schema.isUUID()), name: 'UUID' },
+        { schema: Schema.String.check(Schema.isULID()), name: 'ULID' },
+        { schema: Schema.String.check(Schema.isMinLength(5)), name: 'minLength' },
         {
-          schema: Schema.String.pipe(Schema.pattern(/^[A-Z]+$/)),
+          schema: Schema.String.check(Schema.isPattern(/^[A-Z]+$/)),
           name: 'pattern',
         },
       ]
@@ -71,8 +165,7 @@ describe('getColumnDefForSchema', () => {
     it('should map number refinements to real column', () => {
       const refinements = [
         { schema: Schema.Finite, name: 'Finite' },
-        { schema: Schema.Number.pipe(Schema.positive()), name: 'positive' },
-        { schema: Schema.Number.pipe(Schema.between(0, 100)), name: 'between' },
+        { schema: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 100 })), name: 'between' },
       ]
 
       for (const { schema, name } of refinements) {
@@ -101,12 +194,7 @@ describe('getColumnDefForSchema', () => {
 
   describe('transformations', () => {
     it('should map transformations based on target type', () => {
-      const StringToNumber = Schema.String.pipe(
-        Schema.transform(Schema.Number, {
-          decode: Number.parseFloat,
-          encode: String,
-        }),
-      )
+      const StringToNumber = Schema.FiniteFromString
 
       const columnDef = State.SQLite.getColumnDefForSchema(StringToNumber)
       expect(columnDef.columnType).toBe('text') // Based on the encoded type (String)
@@ -122,7 +210,7 @@ describe('getColumnDefForSchema', () => {
     it('should map structs to json column', () => {
       const UserSchema = Schema.Struct({
         name: Schema.String,
-        age: Schema.Number,
+        age: Schema.Finite,
       })
 
       const columnDef = State.SQLite.getColumnDefForSchema(UserSchema)
@@ -135,22 +223,22 @@ describe('getColumnDefForSchema', () => {
     })
 
     it('should map records to json column', () => {
-      const columnDef = State.SQLite.getColumnDefForSchema(Schema.Record({ key: Schema.String, value: Schema.Number }))
+      const columnDef = State.SQLite.getColumnDefForSchema(Schema.Record(Schema.String, Schema.Finite))
       expect(columnDef.columnType).toBe('text')
     })
 
     it('should map tuples to json column', () => {
-      const columnDef = State.SQLite.getColumnDefForSchema(Schema.Tuple(Schema.String, Schema.Number))
+      const columnDef = State.SQLite.getColumnDefForSchema(Schema.Tuple([Schema.String, Schema.Finite]))
       expect(columnDef.columnType).toBe('text')
     })
 
     it('should map tagged unions to json column', () => {
-      const ResultSchema = Schema.Union(
+      const ResultSchema = Schema.Union([
         Schema.TaggedStruct('success', {
           value: Schema.String,
         }),
         Schema.TaggedStruct('error', { error: Schema.String }),
-      )
+      ])
 
       const columnDef = State.SQLite.getColumnDefForSchema(ResultSchema)
       expect(columnDef.columnType).toBe('text')
@@ -173,7 +261,7 @@ describe('getColumnDefForSchema', () => {
 
     it('should handle optional nested schemas', () => {
       const columnDef = State.SQLite.getColumnDefForSchema(
-        Schema.Union(Schema.Struct({ name: Schema.String }), Schema.Undefined),
+        Schema.Union([Schema.Struct({ name: Schema.String }), Schema.Undefined]),
       )
       expect(columnDef.columnType).toBe('text')
     })
@@ -198,7 +286,7 @@ describe('getColumnDefForSchema', () => {
 
     it('should handle never schema', () => {
       // Create a schema that should never validate
-      const neverSchema = Schema.String.pipe(Schema.filter(() => false, { message: () => 'Always fails' }))
+      const neverSchema = Schema.String.check(Schema.makeFilter(() => false, { message: 'Always fails' }))
 
       const columnDef = State.SQLite.getColumnDefForSchema(neverSchema)
       expect(columnDef.columnType).toBe('text')
@@ -234,7 +322,7 @@ describe('getColumnDefForSchema', () => {
         email: Schema.String,
       })
 
-      const PickedSchema = UserSchema.pipe(Schema.pick('id', 'name'))
+      const PickedSchema = UserSchema.mapFields(Struct.pick(['id', 'name']))
 
       const columnDef = State.SQLite.getColumnDefForSchema(PickedSchema)
       expect(columnDef.columnType).toBe('text')
@@ -247,7 +335,7 @@ describe('getColumnDefForSchema', () => {
         password: Schema.String,
       })
 
-      const PublicUserSchema = UserSchema.pipe(Schema.omit('password'))
+      const PublicUserSchema = UserSchema.mapFields(Struct.omit(['password']))
 
       const columnDef = State.SQLite.getColumnDefForSchema(PublicUserSchema)
       expect(columnDef.columnType).toBe('text')
@@ -256,10 +344,10 @@ describe('getColumnDefForSchema', () => {
 
   describe('annotations', () => {
     it('should handle schemas with custom annotations', () => {
-      const AnnotatedString = Schema.String.annotations({
+      const AnnotatedString = Schema.String.annotate({
         description: 'A special string',
       })
-      const AnnotatedNumber = Schema.Number.annotations({ min: 0, max: 100 })
+      const AnnotatedNumber = Schema.Finite.annotate({ min: 0, max: 100 })
 
       expect(State.SQLite.getColumnDefForSchema(AnnotatedString).columnType).toBe('text')
       expect(State.SQLite.getColumnDefForSchema(AnnotatedNumber).columnType).toBe('real')
@@ -268,20 +356,20 @@ describe('getColumnDefForSchema', () => {
 
   describe('enums and literal unions', () => {
     it('should handle enums and literal unions as text', () => {
-      const StatusEnum = Schema.Enums({
+      const StatusEnum = Schema.Enum({
         PENDING: 'pending',
         ACTIVE: 'active',
         INACTIVE: 'inactive',
       })
 
-      const StatusUnion = Schema.Literal('pending', 'active', 'inactive')
+      const StatusUnion = Schema.Literals(['pending', 'active', 'inactive'])
 
       expect(State.SQLite.getColumnDefForSchema(StatusEnum).columnType).toBe('text')
       expect(State.SQLite.getColumnDefForSchema(StatusUnion).columnType).toBe('text')
     })
 
     it('should handle unions of numeric literals as integer column', () => {
-      const IntervalSchema = Schema.Literal(1, 5, 15, 30)
+      const IntervalSchema = Schema.Literals([1, 5, 15, 30])
 
       const columnDef = State.SQLite.getColumnDefForSchema(IntervalSchema)
 
@@ -289,7 +377,7 @@ describe('getColumnDefForSchema', () => {
     })
 
     it('should handle unions of non-integer numeric literals as real column', () => {
-      const PercentSchema = Schema.Literal(0.1, 0.2, 0.25)
+      const PercentSchema = Schema.Literals([0.1, 0.2, 0.25])
 
       const columnDef = State.SQLite.getColumnDefForSchema(PercentSchema)
 
@@ -298,10 +386,25 @@ describe('getColumnDefForSchema', () => {
   })
 
   describe('binary data', () => {
-    it('should handle Uint8Array as blob column', () => {
+    it('should handle Uint8Array as blob column', async () => {
       const columnDef = State.SQLite.getColumnDefForSchema(Schema.Uint8Array)
       expect(columnDef.columnType).toBe('blob')
-      expect(objectToString(columnDef.schema)).toBe('Uint8ArrayFromSelf')
+      expect(
+        SchemaAST.resolveAt<{ readonly id: string }>('representation')(Schema.toType(columnDef.schema).ast)?.id,
+      ).toBe('effect/schema/Uint8Array')
+
+      const asserts = new TestSchema.Asserts(columnDef.schema)
+      await asserts.decoding().succeed(new Uint8Array([1, 2, 3]))
+    })
+
+    it('should preserve Uint8Array checks on blob columns', () => {
+      const schema = Schema.Uint8Array.check(Schema.makeFilter((value) => value.byteLength > 0))
+      const columnDef = State.SQLite.getColumnDefForSchema(schema)
+
+      expect(columnDef.columnType).toBe('blob')
+      expect(columnDef.schema).toBe(schema)
+      expect(Schema.decodeSync(columnDef.schema)(new Uint8Array([1]))).toEqual(new Uint8Array([1]))
+      expect(() => Schema.decodeSync(columnDef.schema)(new Uint8Array())).toThrow()
     })
   })
 
@@ -322,12 +425,12 @@ describe('getColumnDefForSchema', () => {
   })
 
   describe('schema-based table definitions', () => {
-    it('should handle optional fields in schema', () => {
+    it('should handle optional fields in schema', async () => {
       const UserSchema = Schema.Struct({
         id: Schema.String,
         name: Schema.String,
         email: Schema.optional(Schema.String),
-        age: Schema.optional(Schema.Number),
+        age: Schema.optional(Schema.Finite),
       })
 
       const userTable = State.SQLite.table({
@@ -343,12 +446,16 @@ describe('getColumnDefForSchema', () => {
       expect(userTable.sqliteDef.columns.id.nullable).toBe(false)
       expect(userTable.sqliteDef.columns.name.nullable).toBe(false)
 
-      // Row schema should show | null for optional fields
-      expect((userTable.rowSchema as any).fields.email.toString()).toBe('string | null')
-      expect((userTable.rowSchema as any).fields.age.toString()).toBe('number | null')
+      const asserts = new TestSchema.Asserts(userTable.rowSchema)
+      await asserts.decoding().succeed({
+        id: 'user-1',
+        name: 'Ada',
+        email: null,
+        age: null,
+      })
     })
 
-    it('should handle optional boolean with proper transformation', () => {
+    it('should handle optional boolean with proper transformation', async () => {
       const schema = Schema.Struct({
         id: Schema.String,
         active: Schema.optional(Schema.Boolean),
@@ -358,11 +465,13 @@ describe('getColumnDefForSchema', () => {
 
       expect(table.sqliteDef.columns.active.nullable).toBe(true)
       expect(table.sqliteDef.columns.active.columnType).toBe('integer')
-      expect(objectToString(table.sqliteDef.columns.active.schema)).toBe('(number <-> boolean) | null')
-      expect(String((table.rowSchema as any).fields.active)).toBe('(number <-> boolean) | null')
+      const asserts = new TestSchema.Asserts(table.rowSchema)
+      await asserts.decoding().succeed({ id: 'row-1', active: 1 }, { id: 'row-1', active: true })
+      expect(Schema.encodeSync(table.sqliteDef.columns.active.schema)(false)).toBe(0)
+      await asserts.decoding().succeed({ id: 'row-1', active: null })
     })
 
-    it('should handle optional complex types with JSON encoding', () => {
+    it('should handle optional complex types with JSON encoding', async () => {
       const schema = Schema.Struct({
         id: Schema.String,
         metadata: Schema.optional(Schema.Struct({ color: Schema.String })),
@@ -373,17 +482,27 @@ describe('getColumnDefForSchema', () => {
 
       expect(table.sqliteDef.columns.metadata.nullable).toBe(true)
       expect(table.sqliteDef.columns.metadata.columnType).toBe('text')
-      expect((table.rowSchema as any).fields.metadata.toString()).toBe(
-        '(parseJson <-> { readonly color: string }) | null',
-        // '(parseJson <-> { readonly color: string } | null)', //  not sure yet about which semantics we want here
-      )
 
       expect(table.sqliteDef.columns.tags.nullable).toBe(true)
       expect(table.sqliteDef.columns.tags.columnType).toBe('text')
-      expect((table.rowSchema as any).fields.tags.toString()).toBe('(parseJson <-> ReadonlyArray<string>) | null')
+
+      const asserts = new TestSchema.Asserts(table.rowSchema)
+      await asserts.decoding().succeed(
+        {
+          id: 'row-1',
+          metadata: JSON.stringify({ color: 'red' }),
+          tags: JSON.stringify(['urgent', 'local']),
+        },
+        {
+          id: 'row-1',
+          metadata: { color: 'red' },
+          tags: ['urgent', 'local'],
+        },
+      )
+      await asserts.decoding().succeed({ id: 'row-1', metadata: null, tags: null })
     })
 
-    it('should handle Schema.NullOr', () => {
+    it('should handle Schema.NullOr', async () => {
       const schema = Schema.Struct({
         id: Schema.String,
         description: Schema.NullOr(Schema.String),
@@ -395,41 +514,55 @@ describe('getColumnDefForSchema', () => {
       expect(table.sqliteDef.columns.description.nullable).toBe(true)
       expect(table.sqliteDef.columns.count.nullable).toBe(true)
 
-      expect((table.rowSchema as any).fields.description.toString()).toBe('string | null')
-      expect((table.rowSchema as any).fields.count.toString()).toBe('Int | null')
+      const asserts = new TestSchema.Asserts(table.rowSchema)
+      await asserts.decoding().succeed({
+        id: 'row-1',
+        description: 'ready',
+        count: 1,
+      })
+      await asserts.decoding().succeed({
+        id: 'row-1',
+        description: null,
+        count: null,
+      })
     })
 
-    it('should treat unions of string literals as text columns without JSON parsing', () => {
+    it('should treat unions of string literals as text columns without JSON parsing', async () => {
       const schema = Schema.Struct({
         id: Schema.String,
-        status: Schema.Literal('idle', 'running', 'stopped'),
+        status: Schema.Literals(['idle', 'running', 'stopped']),
       })
 
       const table = State.SQLite.table({ name: 'timers', schema })
 
       expect(table.sqliteDef.columns.status.columnType).toBe('text')
-      expect(objectToString(table.sqliteDef.columns.status.schema)).toBe('"idle" | "running" | "stopped"')
-      expect(String((table.rowSchema as any).fields.status)).toBe('"idle" | "running" | "stopped"')
+      expect(Schema.toEncoded(table.sqliteDef.columns.status.schema).ast._tag).toBe('Union')
+
+      const asserts = new TestSchema.Asserts(table.rowSchema)
+      await asserts.decoding().succeed({ id: 'timer-1', status: 'idle' })
     })
 
-    it('should handle Schema.NullOr with complex types', () => {
+    it('should handle Schema.NullOr with complex types', async () => {
       const schema = Schema.Struct({
-        data: Schema.NullOr(Schema.Struct({ value: Schema.Number })),
-      }).annotations({ title: 'test' })
+        data: Schema.NullOr(Schema.Struct({ value: Schema.Finite })),
+      }).annotate({ title: 'test' })
 
       const table = State.SQLite.table({ schema })
 
       expect(table.sqliteDef.columns.data.nullable).toBe(true)
       expect(table.sqliteDef.columns.data.columnType).toBe('text')
-      expect((table.rowSchema as any).fields.data.toString()).toBe('(parseJson <-> { readonly value: number }) | null')
+
+      const asserts = new TestSchema.Asserts(table.rowSchema)
+      await asserts.decoding().succeed({ data: JSON.stringify({ value: 42 }) }, { data: { value: 42 } })
+      await asserts.decoding().succeed({ data: null })
     })
 
-    it('should handle mixed nullable and optional fields', () => {
+    it('should handle mixed nullable and optional fields', async () => {
       const schema = Schema.Struct({
         nullableText: Schema.NullOr(Schema.String),
         optionalText: Schema.optional(Schema.String),
-        optionalJson: Schema.optional(Schema.Struct({ x: Schema.Number })),
-      }).annotations({ title: 'test' })
+        optionalJson: Schema.optional(Schema.Struct({ x: Schema.Finite })),
+      }).annotate({ title: 'test' })
 
       const table = State.SQLite.table({ schema })
 
@@ -438,12 +571,15 @@ describe('getColumnDefForSchema', () => {
       expect(table.sqliteDef.columns.optionalText.nullable).toBe(true)
       expect(table.sqliteDef.columns.optionalJson.nullable).toBe(true)
 
-      // Schema representations
-      expect((table.rowSchema as any).fields.nullableText.toString()).toBe('string | null')
-      expect((table.rowSchema as any).fields.optionalText.toString()).toBe('string | null')
-      expect((table.rowSchema as any).fields.optionalJson.toString()).toBe(
-        '(parseJson <-> { readonly x: number }) | null',
-      )
+      const nullableTextAsserts = new TestSchema.Asserts(table.sqliteDef.columns.nullableText.schema)
+      const optionalTextAsserts = new TestSchema.Asserts(table.sqliteDef.columns.optionalText.schema)
+      const optionalJsonAsserts = new TestSchema.Asserts(table.sqliteDef.columns.optionalJson.schema)
+
+      await nullableTextAsserts.decoding().succeed('hello')
+      await nullableTextAsserts.decoding().succeed(null)
+      await optionalTextAsserts.decoding().succeed(null)
+      await optionalJsonAsserts.decoding().succeed(JSON.stringify({ x: 1 }), { x: 1 })
+      await optionalJsonAsserts.decoding().succeed(null)
     })
 
     // TODO bring back some time later
@@ -452,7 +588,7 @@ describe('getColumnDefForSchema', () => {
     //     id: Schema.String,
     //     lossyText: Schema.optional(Schema.NullOr(Schema.String)),
     //     lossyComplex: Schema.optional(Schema.NullOr(Schema.Struct({ value: Schema.Number }))),
-    //   }).annotations({ title: 'lossy_test' })
+    //   }).annotate({ title: 'lossy_test' })
 
     //   const table = State.SQLite.table({ schema })
 
@@ -476,7 +612,7 @@ describe('getColumnDefForSchema', () => {
   describe('annotations', () => {
     describe('withColumnType', () => {
       it('should respect column type annotation for text', () => {
-        const schema = Schema.Number.pipe(withColumnType('text'))
+        const schema = Schema.Finite.pipe(withColumnType('text'))
         const columnDef = State.SQLite.getColumnDefForSchema(schema)
         expect(columnDef.columnType).toBe('text')
       })
@@ -501,7 +637,7 @@ describe('getColumnDefForSchema', () => {
 
       it('should override default type mapping', () => {
         // Number normally maps to real, but we override to text
-        const schema = Schema.Number.pipe(withColumnType('text'))
+        const schema = Schema.Finite.pipe(withColumnType('text'))
         const columnDef = State.SQLite.getColumnDefForSchema(schema)
         expect(columnDef.columnType).toBe('text')
       })
@@ -540,7 +676,7 @@ describe('getColumnDefForSchema', () => {
       it('should throw when primary key is used with optional schema', () => {
         // Note: Schema.optional returns a property signature, not a schema, so we can't pipe it
         // Instead, we use Schema.Union to create an optional schema that can be piped
-        const optionalString = Schema.Union(Schema.String, Schema.Undefined)
+        const optionalString = Schema.Union([Schema.String, Schema.Undefined])
         const UserSchema = Schema.Struct({
           id: optionalString.pipe(withPrimaryKey),
           name: Schema.String,
@@ -570,7 +706,7 @@ describe('getColumnDefForSchema', () => {
 
       it('should work with column type annotation', () => {
         const UserSchema = Schema.Struct({
-          id: Schema.Number.pipe(withColumnType('integer'), withPrimaryKey),
+          id: Schema.Finite.pipe(withColumnType('integer'), withPrimaryKey),
           name: Schema.String,
         })