@livestore/common 0.4.0 → 0.5.0-dev.1

package/dist/schema/state/sqlite/column-def.test.js

@@ -1,8 +1,8 @@
+import { TestSchema } from 'effect/testing';
 import { assert, describe, expect, it } from 'vitest';
-import { Schema } from '@livestore/utils/effect';
-import { objectToString } from '@livestore/utils';
-import * as State from "../mod.js";
-import { withAutoIncrement, withColumnType, withDefault, withPrimaryKey, withUnique } from "./column-annotations.js";
+import { Schema, SchemaAST, SchemaTransformation, Struct } from '@livestore/utils/effect';
+import * as State from '../mod.js';
+import { withAutoIncrement, withColumnType, withDefault, withPrimaryKey, withUnique } from './column-annotations.js';
 describe('getColumnDefForSchema', () => {
     describe('basic types', () => {
         it('should map Schema.String to text column', () => {
@@ -10,7 +10,7 @@ describe('getColumnDefForSchema', () => {
             expect(columnDef.columnType).toBe('text');
         });
         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');
         });
         it('should map Schema.Boolean to integer column', () => {
@@ -20,14 +20,73 @@ 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');
-        });
-        it('should map Schema.DateFromNumber to integer column', () => {
-            const columnDef = State.SQLite.getColumnDefForSchema(Schema.DateFromNumber);
+            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('representation')(Schema.toType(columnDef.schema).ast)?.id).toBe('effect/schema/Date');
+        });
+        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('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'])('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', () => {
             const columnDef = State.SQLite.getColumnDefForSchema(Schema.BigInt);
@@ -38,16 +97,18 @@ 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',
                 },
             ];
@@ -59,8 +120,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) {
                 const columnDef = State.SQLite.getColumnDefForSchema(schema);
@@ -84,10 +144,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)
         });
@@ -100,7 +157,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);
             expect(columnDef.columnType).toBe('text');
@@ -110,17 +167,20 @@ describe('getColumnDefForSchema', () => {
             expect(columnDef.columnType).toBe('text');
         });
         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(Schema.TaggedStruct('success', {
-                value: Schema.String,
-            }), Schema.TaggedStruct('error', { error: Schema.String }));
+            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');
         });
@@ -138,7 +198,7 @@ describe('getColumnDefForSchema', () => {
             expect(columnDef.columnType).toBe('text');
         });
         it('should handle optional nested schemas', () => {
-            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Union(Schema.Struct({ name: Schema.String }), Schema.Undefined));
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Union([Schema.Struct({ name: Schema.String }), Schema.Undefined]));
             expect(columnDef.columnType).toBe('text');
         });
     });
@@ -159,7 +219,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');
         });
@@ -188,7 +248,7 @@ describe('getColumnDefForSchema', () => {
                 name: Schema.String,
                 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');
         });
@@ -198,48 +258,58 @@ describe('getColumnDefForSchema', () => {
                 name: Schema.String,
                 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');
         });
     });
     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');
         });
     });
     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);
             expect(columnDef.columnType).toBe('integer');
         });
         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);
             expect(columnDef.columnType).toBe('real');
         });
     });
     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('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();
         });
     });
     describe('recursive schemas', () => {
@@ -253,12 +323,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({
                 name: 'users',
@@ -270,11 +340,15 @@ describe('getColumnDefForSchema', () => {
             // Non-optional fields should not be nullable
             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.fields.email.toString()).toBe('string | null');
-            expect(userTable.rowSchema.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),
@@ -282,10 +356,12 @@ describe('getColumnDefForSchema', () => {
             const table = State.SQLite.table({ name: 'test', schema });
             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.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 })),
@@ -294,12 +370,21 @@ describe('getColumnDefForSchema', () => {
             const table = State.SQLite.table({ name: 'test', schema });
             expect(table.sqliteDef.columns.metadata.nullable).toBe(true);
             expect(table.sqliteDef.columns.metadata.columnType).toBe('text');
-            expect(table.rowSchema.fields.metadata.toString()).toBe('(parseJson <-> { readonly color: string }) | null');
             expect(table.sqliteDef.columns.tags.nullable).toBe(true);
             expect(table.sqliteDef.columns.tags.columnType).toBe('text');
-            expect(table.rowSchema.fields.tags.toString()).toBe('(parseJson <-> ReadonlyArray<string>) | null');
-        });
-        it('should handle Schema.NullOr', () => {
+            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', async () => {
             const schema = Schema.Struct({
                 id: Schema.String,
                 description: Schema.NullOr(Schema.String),
@@ -308,43 +393,59 @@ describe('getColumnDefForSchema', () => {
             const table = State.SQLite.table({ name: 'test', schema });
             expect(table.sqliteDef.columns.description.nullable).toBe(true);
             expect(table.sqliteDef.columns.count.nullable).toBe(true);
-            expect(table.rowSchema.fields.description.toString()).toBe('string | null');
-            expect(table.rowSchema.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.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.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 });
             // Both should be nullable at column level
             expect(table.sqliteDef.columns.nullableText.nullable).toBe(true);
             expect(table.sqliteDef.columns.optionalText.nullable).toBe(true);
             expect(table.sqliteDef.columns.optionalJson.nullable).toBe(true);
-            // Schema representations
-            expect(table.rowSchema.fields.nullableText.toString()).toBe('string | null');
-            expect(table.rowSchema.fields.optionalText.toString()).toBe('string | null');
-            expect(table.rowSchema.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
         // it('should handle lossy Schema.optional(Schema.NullOr(...)) with JSON encoding', () => {
@@ -352,7 +453,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 })
         //   // Check column definitions for lossy fields
         //   expect(table.sqliteDef.columns.lossyText.nullable).toBe(true)
@@ -371,7 +472,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');
             });
@@ -392,7 +493,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');
             });
@@ -424,7 +525,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,
@@ -446,7 +547,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,
                 });
                 const userTable = State.SQLite.table({