@livestore/common 0.3.2-dev.9 → 0.4.0-dev.0

package/dist/schema/state/sqlite/table-def.js.map

@@ -1 +1 @@
-{"version":3,"file":"table-def.js","sourceRoot":"","sources":["../../../../src/schema/state/sqlite/table-def.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAE9C,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAEpG,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,SAAS,CAAA;AAO3G,uCAAuC;AACvC,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAA;AAqDlE,MAAM,CAAC,MAAM,KAAK,GAAG,CAKnB,IAG0B,EACiD,EAAE;IAC7E,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,eAAe,EAAE,GAAG,OAAO,EAAE,GAAG,IAAI,CAAA;IAC3D,MAAM,SAAS,GAAG,IAAI,CAAA;IAEtB,MAAM,QAAQ,GAAiB;QAC7B,qBAAqB,EAAE,KAAK;KAC7B,CAAA;IAED,MAAM,OAAO,GAAG,CACd,SAAS,CAAC,kBAAkB,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC,eAAe,CACxE,CAAA;IAEtB,MAAM,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,EAAE,CAAC,CAAA;IAE7E,MAAM,SAAS,GAAG,SAAS,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAA;IAC3D,MAAM,YAAY,GAAG,SAAS,CAAC,0BAA0B,CAAC,SAAS,CAAC,CAAA;IACpE,MAAM,QAAQ,GAAG;QACf,SAAS;QACT,OAAO,EAAE,QAAQ;QACjB,SAAS;QACT,YAAY;KACU,CAAA;IAExB,MAAM,KAAK,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAA;IACxC,yBAAyB;IAEzB,6DAA6D;IAC7D,sDAAsD;IACtD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACrC,gDAAgD;QAChD,QAAQ,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA;IAC5B,CAAC;IAED,2CAA2C;IAC3C,QAAQ,CAAC,qBAAqB,CAAC,GAAG,KAAK,CAAC,qBAAqB,CAAC,CAAA;IAC9D,2CAA2C;IAC3C,QAAQ,CAAC,kBAAkB,CAAC,GAAG,KAAK,CAAC,kBAAkB,CAAC,CAAA;IAExD,OAAO,QAAe,CAAA;AACxB,CAAC,CAAA"}
+{"version":3,"file":"table-def.js","sourceRoot":"","sources":["../../../../src/schema/state/sqlite/table-def.ts"],"names":[],"mappings":"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"}

package/dist/schema/state/sqlite/table-def.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=table-def.test.d.ts.map

package/dist/schema/state/sqlite/table-def.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-def.test.d.ts","sourceRoot":"","sources":["../../../../src/schema/state/sqlite/table-def.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,635 @@
+import { Schema } from '@livestore/utils/effect';
+import { describe, expect, it } from 'vitest';
+import { State } from "../../mod.js";
+import { withAutoIncrement, withColumnType, withDefault, withPrimaryKey, withUnique } from "./column-annotations.js";
+describe('table function overloads', () => {
+    it('should extract table name from title annotation', () => {
+        const TodoSchema = Schema.Struct({
+            id: Schema.String,
+            text: Schema.String,
+            completed: Schema.Boolean,
+        }).annotations({ title: 'todos' });
+        const todosTable = State.SQLite.table({
+            schema: TodoSchema,
+        });
+        expect(todosTable.sqliteDef.name).toBe('todos');
+    });
+    it('should extract table name from identifier annotation', () => {
+        const TodoSchema = Schema.Struct({
+            id: Schema.String,
+            text: Schema.String,
+            completed: Schema.Boolean,
+        }).annotations({ identifier: 'TodoItem' });
+        const todosTable = State.SQLite.table({ schema: TodoSchema });
+        expect(todosTable.sqliteDef.name).toBe('TodoItem');
+    });
+    it('should prefer title over identifier annotation', () => {
+        const TodoSchema = Schema.Struct({
+            id: Schema.String,
+            text: Schema.String,
+            completed: Schema.Boolean,
+        }).annotations({
+            title: 'todos',
+            identifier: 'TodoItem',
+        });
+        const todosTable = State.SQLite.table({ schema: TodoSchema });
+        expect(todosTable.sqliteDef.name).toBe('todos');
+    });
+    it('should throw when schema has no name, title, or identifier', () => {
+        const TodoSchema = Schema.Struct({
+            id: Schema.String,
+            text: Schema.String,
+            completed: Schema.Boolean,
+        });
+        expect(() => State.SQLite.table({ schema: TodoSchema })).toThrow('When using schema without explicit name, the schema must have a title or identifier annotation');
+    });
+    it('should work with columns parameter', () => {
+        const todosTable = State.SQLite.table({
+            name: 'todos',
+            columns: {
+                id: State.SQLite.text({ primaryKey: true }),
+                text: State.SQLite.text({ default: '' }),
+                completed: State.SQLite.boolean({ default: false }),
+            },
+        });
+        expect(todosTable.sqliteDef.name).toBe('todos');
+        expect(todosTable.sqliteDef.columns).toHaveProperty('id');
+        expect(todosTable.sqliteDef.columns).toHaveProperty('text');
+        expect(todosTable.sqliteDef.columns).toHaveProperty('completed');
+    });
+    it('should work with schema parameter', () => {
+        const TodoSchema = Schema.Struct({
+            id: Schema.String,
+            text: Schema.String,
+            completed: Schema.Boolean,
+        });
+        const todosTable = State.SQLite.table({
+            name: 'todos',
+            schema: TodoSchema,
+        });
+        expect(todosTable.sqliteDef.name).toBe('todos');
+        expect(todosTable.sqliteDef.columns).toHaveProperty('id');
+        expect(todosTable.sqliteDef.columns).toHaveProperty('text');
+        expect(todosTable.sqliteDef.columns).toHaveProperty('completed');
+    });
+    it('should work with single column', () => {
+        const simpleTable = State.SQLite.table({
+            name: 'simple',
+            columns: State.SQLite.text({ primaryKey: true }),
+        });
+        expect(simpleTable.sqliteDef.name).toBe('simple');
+        expect(simpleTable.sqliteDef.columns).toHaveProperty('value');
+        expect(simpleTable.sqliteDef.columns.value.primaryKey).toBe(true);
+    });
+    it('should handle optional fields in schema', () => {
+        const UserSchema = Schema.Struct({
+            id: Schema.String,
+            name: Schema.String,
+            email: Schema.optional(Schema.String),
+        });
+        const userTable = State.SQLite.table({
+            name: 'users',
+            schema: UserSchema,
+        });
+        expect(userTable.sqliteDef.columns.id.nullable).toBe(false);
+        expect(userTable.sqliteDef.columns.name.nullable).toBe(false);
+        expect(userTable.sqliteDef.columns.email.nullable).toBe(true);
+    });
+    it('should handle Schema.Int as integer column', () => {
+        const CounterSchema = Schema.Struct({
+            id: Schema.String,
+            count: Schema.Int,
+        });
+        const counterTable = State.SQLite.table({
+            name: 'counters',
+            schema: CounterSchema,
+        });
+        expect(counterTable.sqliteDef.columns.count.columnType).toBe('integer');
+    });
+    it('should work with Schema.Class', () => {
+        class User extends Schema.Class('User')({
+            id: Schema.String,
+            name: Schema.String,
+            email: Schema.optional(Schema.String),
+            age: Schema.Int,
+        }) {
+        }
+        const userTable = State.SQLite.table({
+            name: 'users',
+            schema: User,
+        });
+        expect(userTable.sqliteDef.name).toBe('users');
+        expect(userTable.sqliteDef.columns).toHaveProperty('id');
+        expect(userTable.sqliteDef.columns).toHaveProperty('name');
+        expect(userTable.sqliteDef.columns).toHaveProperty('email');
+        expect(userTable.sqliteDef.columns).toHaveProperty('age');
+        // Check column types
+        expect(userTable.sqliteDef.columns.id.columnType).toBe('text');
+        expect(userTable.sqliteDef.columns.name.columnType).toBe('text');
+        expect(userTable.sqliteDef.columns.email.columnType).toBe('text');
+        expect(userTable.sqliteDef.columns.email.nullable).toBe(true);
+        expect(userTable.sqliteDef.columns.age.columnType).toBe('integer');
+    });
+    it('should extract table name from Schema.Class identifier', () => {
+        class TodoItem extends Schema.Class('TodoItem')({
+            id: Schema.String,
+            text: Schema.String,
+            completed: Schema.Boolean,
+        }) {
+        }
+        // Schema.Class doesn't set identifier/title annotations, so we need to provide an explicit name
+        const todosTable = State.SQLite.table({
+            name: 'TodoItem',
+            schema: TodoItem,
+        });
+        expect(todosTable.sqliteDef.name).toBe('TodoItem');
+    });
+    it('should properly infer types from schema', () => {
+        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 })),
+        });
+        const userTable = State.SQLite.table({
+            name: 'users',
+            schema: UserSchema,
+        });
+        const _userTypeCheck = {
+            id: 'test-id',
+            name: 'John',
+            age: 30,
+            active: true,
+            metadata: { key1: 'value1', key2: 123 },
+        };
+        // Should derive proper column schema
+        expect(userTable.rowSchema.fields.age.toString()).toMatchInlineSnapshot(`"number"`);
+        expect(userTable.rowSchema.fields.active.toString()).toMatchInlineSnapshot(`"(number <-> boolean)"`);
+        expect(userTable.rowSchema.fields.metadata.toString()).toMatchInlineSnapshot(`"(parseJson <-> { readonly [x: string]: unknown })"`);
+        // These should compile without errors
+        const _idCheck = 'string';
+        const _nameCheck = 'string';
+        const _ageCheck = 123;
+        const _activeCheck = true;
+        const _metadataCheck = { foo: 'bar' };
+        // Verify column definitions
+        expect(userTable.sqliteDef.columns.id.columnType).toBe('text');
+        expect(userTable.sqliteDef.columns.name.columnType).toBe('text');
+        expect(userTable.sqliteDef.columns.age.columnType).toBe('integer');
+        expect(userTable.sqliteDef.columns.active.columnType).toBe('integer');
+        expect(userTable.sqliteDef.columns.metadata.columnType).toBe('text');
+        expect(userTable.sqliteDef.columns.metadata.nullable).toBe(true);
+    });
+});
+describe('getColumnDefForSchema', () => {
+    describe('basic types', () => {
+        it('should map Schema.String to text column', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.String);
+            expect(columnDef.columnType).toBe('text');
+        });
+        it('should map Schema.Number to real column', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Number);
+            expect(columnDef.columnType).toBe('real');
+        });
+        it('should map Schema.Boolean to integer column', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Boolean);
+            expect(columnDef.columnType).toBe('integer');
+        });
+        it('should map Schema.Date to text column', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Date);
+            expect(columnDef.columnType).toBe('text');
+        });
+        it('should map Schema.BigInt to text column', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.BigInt);
+            expect(columnDef.columnType).toBe('text');
+        });
+    });
+    describe('refinements', () => {
+        it('should map Schema.Int to integer column', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Int);
+            expect(columnDef.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.pipe(Schema.pattern(/^[A-Z]+$/)), name: 'pattern' },
+            ];
+            for (const { schema, name } of refinements) {
+                const columnDef = State.SQLite.getColumnDefForSchema(schema);
+                expect(columnDef.columnType, `${name} should map to text`).toBe('text');
+            }
+        });
+        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' },
+            ];
+            for (const { schema, name } of refinements) {
+                const columnDef = State.SQLite.getColumnDefForSchema(schema);
+                expect(columnDef.columnType, `${name} should map to real`).toBe('real');
+            }
+        });
+    });
+    describe('literal types', () => {
+        it('should map string literals to text column', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Literal('active'));
+            expect(columnDef.columnType).toBe('text');
+        });
+        it('should map number literals to real column', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Literal(42));
+            expect(columnDef.columnType).toBe('real');
+        });
+        it('should map boolean literals to integer column', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Literal(true));
+            expect(columnDef.columnType).toBe('integer');
+        });
+    });
+    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 columnDef = State.SQLite.getColumnDefForSchema(StringToNumber);
+            expect(columnDef.columnType).toBe('real'); // Based on the target type (Number)
+        });
+        it('should handle Date transformations', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Date);
+            expect(columnDef.columnType).toBe('text');
+        });
+    });
+    describe('complex types', () => {
+        it('should map structs to json column', () => {
+            const UserSchema = Schema.Struct({
+                name: Schema.String,
+                age: Schema.Number,
+            });
+            const columnDef = State.SQLite.getColumnDefForSchema(UserSchema);
+            expect(columnDef.columnType).toBe('text');
+        });
+        it('should map arrays to json column', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Array(Schema.String));
+            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 }));
+            expect(columnDef.columnType).toBe('text');
+        });
+        it('should map tuples to json column', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Tuple(Schema.String, Schema.Number));
+            expect(columnDef.columnType).toBe('text');
+        });
+        it('should map tagged unions to json column', () => {
+            const ResultSchema = Schema.Union(Schema.Struct({ _tag: Schema.Literal('success'), value: Schema.String }), Schema.Struct({ _tag: Schema.Literal('error'), error: Schema.String }));
+            const columnDef = State.SQLite.getColumnDefForSchema(ResultSchema);
+            expect(columnDef.columnType).toBe('text');
+        });
+    });
+    describe('nested schemas', () => {
+        it('should handle deeply nested schemas', () => {
+            const NestedSchema = Schema.Struct({
+                level1: Schema.Struct({
+                    level2: Schema.Struct({
+                        value: Schema.String,
+                    }),
+                }),
+            });
+            const columnDef = State.SQLite.getColumnDefForSchema(NestedSchema);
+            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));
+            expect(columnDef.columnType).toBe('text');
+        });
+    });
+    describe('edge cases', () => {
+        it('should default to json column for unhandled types', () => {
+            // Test various edge cases that all result in JSON columns
+            const edgeCases = [
+                { schema: Schema.Unknown, name: 'Unknown' },
+                { schema: Schema.Any, name: 'Any' },
+                { schema: Schema.Null, name: 'Null' },
+                { schema: Schema.Undefined, name: 'Undefined' },
+                { schema: Schema.Void, name: 'Void' },
+            ];
+            for (const { schema, name } of edgeCases) {
+                const columnDef = State.SQLite.getColumnDefForSchema(schema);
+                expect(columnDef.columnType, `${name} should map to text (JSON storage)`).toBe('text');
+            }
+        });
+        it('should handle never schema', () => {
+            // Create a schema that should never validate
+            const neverSchema = Schema.String.pipe(Schema.filter(() => false, { message: () => 'Always fails' }));
+            const columnDef = State.SQLite.getColumnDefForSchema(neverSchema);
+            expect(columnDef.columnType).toBe('text');
+        });
+        it('should handle symbol schema', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Symbol);
+            expect(columnDef.columnType).toBe('text');
+        });
+    });
+    describe('custom schemas', () => {
+        it('should handle Schema.extend', () => {
+            const BaseSchema = Schema.Struct({
+                id: Schema.String,
+                createdAt: Schema.Date,
+            });
+            const ExtendedSchema = Schema.Struct({
+                ...BaseSchema.fields,
+                name: Schema.String,
+                updatedAt: Schema.Date,
+            });
+            const columnDef = State.SQLite.getColumnDefForSchema(ExtendedSchema);
+            expect(columnDef.columnType).toBe('text');
+        });
+        it('should handle Schema.pick', () => {
+            const UserSchema = Schema.Struct({
+                id: Schema.String,
+                name: Schema.String,
+                email: Schema.String,
+            });
+            const PickedSchema = UserSchema.pipe(Schema.pick('id', 'name'));
+            const columnDef = State.SQLite.getColumnDefForSchema(PickedSchema);
+            expect(columnDef.columnType).toBe('text');
+        });
+        it('should handle Schema.omit', () => {
+            const UserSchema = Schema.Struct({
+                id: Schema.String,
+                name: Schema.String,
+                password: Schema.String,
+            });
+            const PublicUserSchema = UserSchema.pipe(Schema.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({ description: 'A special string' });
+            const AnnotatedNumber = Schema.Number.annotations({ 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({
+                PENDING: 'pending',
+                ACTIVE: 'active',
+                INACTIVE: 'inactive',
+            });
+            const StatusUnion = Schema.Union(Schema.Literal('pending'), Schema.Literal('active'), Schema.Literal('inactive'));
+            expect(State.SQLite.getColumnDefForSchema(StatusEnum).columnType).toBe('text');
+            expect(State.SQLite.getColumnDefForSchema(StatusUnion).columnType).toBe('text');
+        });
+    });
+    describe('binary data', () => {
+        it('should handle Uint8Array as blob column', () => {
+            const columnDef = State.SQLite.getColumnDefForSchema(Schema.Uint8Array);
+            expect(columnDef.columnType).toBe('text'); // Stored as JSON
+        });
+    });
+    describe('recursive schemas', () => {
+        it('should handle recursive schemas as json', () => {
+            const TreeNode = Schema.Struct({
+                value: Schema.String,
+                children: Schema.Array(Schema.suspend(() => TreeNode)),
+            });
+            const columnDef = State.SQLite.getColumnDefForSchema(TreeNode);
+            expect(columnDef.columnType).toBe('text'); // Complex type stored as JSON
+        });
+    });
+    describe('annotations', () => {
+        describe('withColumnType', () => {
+            it('should respect column type annotation for text', () => {
+                const schema = Schema.Number.pipe(withColumnType('text'));
+                const columnDef = State.SQLite.getColumnDefForSchema(schema);
+                expect(columnDef.columnType).toBe('text');
+            });
+            it('should respect column type annotation for integer', () => {
+                const schema = Schema.String.pipe(withColumnType('integer'));
+                const columnDef = State.SQLite.getColumnDefForSchema(schema);
+                expect(columnDef.columnType).toBe('integer');
+            });
+            it('should respect column type annotation for real', () => {
+                const schema = Schema.Boolean.pipe(withColumnType('real'));
+                const columnDef = State.SQLite.getColumnDefForSchema(schema);
+                expect(columnDef.columnType).toBe('real');
+            });
+            it('should respect column type annotation for blob', () => {
+                const schema = Schema.String.pipe(withColumnType('blob'));
+                const columnDef = State.SQLite.getColumnDefForSchema(schema);
+                expect(columnDef.columnType).toBe('blob');
+            });
+            it('should override default type mapping', () => {
+                // Number normally maps to real, but we override to text
+                const schema = Schema.Number.pipe(withColumnType('text'));
+                const columnDef = State.SQLite.getColumnDefForSchema(schema);
+                expect(columnDef.columnType).toBe('text');
+            });
+            it('should work with dual API', () => {
+                // Test both forms of the dual API
+                const schema1 = withColumnType(Schema.String, 'integer');
+                const schema2 = Schema.String.pipe(withColumnType('integer'));
+                const columnDef1 = State.SQLite.getColumnDefForSchema(schema1);
+                const columnDef2 = State.SQLite.getColumnDefForSchema(schema2);
+                expect(columnDef1.columnType).toBe('integer');
+                expect(columnDef2.columnType).toBe('integer');
+            });
+        });
+        describe('withPrimaryKey', () => {
+            it('should add primary key annotation to schema', () => {
+                const UserSchema = Schema.Struct({
+                    id: Schema.String.pipe(withPrimaryKey),
+                    name: Schema.String,
+                    email: Schema.optional(Schema.String),
+                    nullable: Schema.NullOr(Schema.Int),
+                });
+                const userTable = State.SQLite.table({
+                    name: 'users',
+                    schema: UserSchema,
+                });
+                expect(userTable.sqliteDef.columns.id.primaryKey).toBe(true);
+                expect(userTable.sqliteDef.columns.id.nullable).toBe(false);
+                expect(userTable.sqliteDef.columns.name.primaryKey).toBe(false);
+                expect(userTable.sqliteDef.columns.email.primaryKey).toBe(false);
+                expect(userTable.sqliteDef.columns.email.nullable).toBe(true);
+                expect(userTable.sqliteDef.columns.nullable.primaryKey).toBe(false);
+                expect(userTable.sqliteDef.columns.nullable.nullable).toBe(true);
+            });
+            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 UserSchema = Schema.Struct({
+                    id: optionalString.pipe(withPrimaryKey),
+                    name: Schema.String,
+                });
+                expect(() => State.SQLite.table({
+                    name: 'users',
+                    schema: UserSchema,
+                })).toThrow('Primary key columns cannot be nullable');
+            });
+            it('should throw when primary key is used with NullOr schema', () => {
+                const UserSchema = Schema.Struct({
+                    id: Schema.NullOr(Schema.String).pipe(withPrimaryKey),
+                    name: Schema.String,
+                });
+                expect(() => State.SQLite.table({
+                    name: 'users',
+                    schema: UserSchema,
+                })).toThrow('Primary key columns cannot be nullable');
+            });
+            it('should work with column type annotation', () => {
+                const UserSchema = Schema.Struct({
+                    id: Schema.Number.pipe(withColumnType('integer')).pipe(withPrimaryKey),
+                    name: Schema.String,
+                });
+                const userTable = State.SQLite.table({
+                    name: 'users',
+                    schema: UserSchema,
+                });
+                expect(userTable.sqliteDef.columns.id.columnType).toBe('integer');
+                expect(userTable.sqliteDef.columns.id.primaryKey).toBe(true);
+            });
+            it('should work with Schema.Int and primary key', () => {
+                const UserSchema = Schema.Struct({
+                    id: Schema.Int.pipe(withPrimaryKey),
+                    name: Schema.String,
+                });
+                const userTable = State.SQLite.table({
+                    name: 'users',
+                    schema: UserSchema,
+                });
+                expect(userTable.sqliteDef.columns.id.columnType).toBe('integer');
+                expect(userTable.sqliteDef.columns.id.primaryKey).toBe(true);
+            });
+        });
+        describe('withAutoIncrement', () => {
+            it('should add autoIncrement annotation to schema', () => {
+                const UserSchema = Schema.Struct({
+                    id: Schema.Int.pipe(withPrimaryKey).pipe(withAutoIncrement),
+                    name: Schema.String,
+                });
+                const userTable = State.SQLite.table({
+                    name: 'users',
+                    schema: UserSchema,
+                });
+                expect(userTable.sqliteDef.columns.id.autoIncrement).toBe(true);
+                expect(userTable.sqliteDef.columns.id.primaryKey).toBe(true);
+                expect(userTable.sqliteDef.columns.id.columnType).toBe('integer');
+            });
+        });
+        describe('withDefault', () => {
+            it('should add default value annotation to schema', () => {
+                const UserSchema = Schema.Struct({
+                    id: Schema.String,
+                    active: Schema.Boolean.pipe(withDefault(true)),
+                    createdAt: Schema.String.pipe(withDefault('CURRENT_TIMESTAMP')),
+                });
+                const userTable = State.SQLite.table({
+                    name: 'users',
+                    schema: UserSchema,
+                });
+                expect(userTable.sqliteDef.columns.active.default._tag).toBe('Some');
+                expect(userTable.sqliteDef.columns.active.default._tag === 'Some' &&
+                    userTable.sqliteDef.columns.active.default.value).toBe(true);
+                expect(userTable.sqliteDef.columns.createdAt.default._tag).toBe('Some');
+                expect(userTable.sqliteDef.columns.createdAt.default._tag === 'Some' &&
+                    userTable.sqliteDef.columns.createdAt.default.value).toBe('CURRENT_TIMESTAMP');
+            });
+            it('should work with dual API', () => {
+                const schema1 = withDefault(Schema.Int, 0);
+                const schema2 = Schema.Int.pipe(withDefault(0));
+                const UserSchema1 = Schema.Struct({ count: schema1 });
+                const UserSchema2 = Schema.Struct({ count: schema2 });
+                const table1 = State.SQLite.table({ name: 't1', schema: UserSchema1 });
+                const table2 = State.SQLite.table({ name: 't2', schema: UserSchema2 });
+                expect(table1.sqliteDef.columns.count.default._tag).toBe('Some');
+                expect(table1.sqliteDef.columns.count.default._tag === 'Some' && table1.sqliteDef.columns.count.default.value).toBe(0);
+                expect(table2.sqliteDef.columns.count.default._tag).toBe('Some');
+                expect(table2.sqliteDef.columns.count.default._tag === 'Some' && table2.sqliteDef.columns.count.default.value).toBe(0);
+            });
+        });
+        describe('withUnique', () => {
+            it('should create unique index for column with unique annotation', () => {
+                const UserSchema = Schema.Struct({
+                    id: Schema.String,
+                    email: Schema.String.pipe(withUnique),
+                    username: Schema.String.pipe(withUnique),
+                });
+                const userTable = State.SQLite.table({
+                    name: 'users',
+                    schema: UserSchema,
+                });
+                // Check that unique indexes were created
+                const uniqueIndexes = userTable.sqliteDef.indexes?.filter((idx) => idx.isUnique) || [];
+                expect(uniqueIndexes).toHaveLength(2);
+                expect(uniqueIndexes.some((idx) => idx.name === 'idx_users_email_unique' && idx.columns.includes('email'))).toBe(true);
+                expect(uniqueIndexes.some((idx) => idx.name === 'idx_users_username_unique' && idx.columns.includes('username'))).toBe(true);
+            });
+            it('should combine unique indexes with user-provided indexes', () => {
+                const UserSchema = Schema.Struct({
+                    id: Schema.String,
+                    email: Schema.String.pipe(withUnique),
+                });
+                const userTable = State.SQLite.table({
+                    name: 'users',
+                    schema: UserSchema,
+                    indexes: [{ name: 'idx_custom', columns: ['id', 'email'] }],
+                });
+                // Should have both custom index and unique index
+                expect(userTable.sqliteDef.indexes).toHaveLength(2);
+                expect(userTable.sqliteDef.indexes?.some((idx) => idx.name === 'idx_custom')).toBe(true);
+                expect(userTable.sqliteDef.indexes?.some((idx) => idx.name === 'idx_users_email_unique')).toBe(true);
+            });
+        });
+        describe('combined annotations', () => {
+            it('should work with multiple annotations', () => {
+                const schema = Schema.Uint8ArrayFromBase64.pipe(withColumnType('blob')).pipe(withPrimaryKey);
+                const UserSchema = Schema.Struct({
+                    id: schema,
+                    name: Schema.String,
+                });
+                const userTable = State.SQLite.table({
+                    name: 'users',
+                    schema: UserSchema,
+                });
+                expect(userTable.sqliteDef.columns.id.columnType).toBe('blob');
+                expect(userTable.sqliteDef.columns.id.primaryKey).toBe(true);
+            });
+            it('should combine all annotations', () => {
+                const UserSchema = Schema.Struct({
+                    id: Schema.Int.pipe(withPrimaryKey).pipe(withAutoIncrement),
+                    email: Schema.String.pipe(withUnique),
+                    status: Schema.String.pipe(withDefault('active')),
+                    metadata: Schema.Unknown.pipe(withColumnType('text')),
+                });
+                const userTable = State.SQLite.table({
+                    name: 'users',
+                    schema: UserSchema,
+                });
+                // Check id column
+                expect(userTable.sqliteDef.columns.id.primaryKey).toBe(true);
+                expect(userTable.sqliteDef.columns.id.autoIncrement).toBe(true);
+                expect(userTable.sqliteDef.columns.id.columnType).toBe('integer');
+                // Check email column and unique index
+                expect(userTable.sqliteDef.columns.email.columnType).toBe('text');
+                expect(userTable.sqliteDef.indexes?.some((idx) => idx.name === 'idx_users_email_unique' && idx.isUnique)).toBe(true);
+                // Check status column
+                expect(userTable.sqliteDef.columns.status.default._tag).toBe('Some');
+                expect(userTable.sqliteDef.columns.status.default._tag === 'Some' &&
+                    userTable.sqliteDef.columns.status.default.value).toBe('active');
+                // Check metadata column
+                expect(userTable.sqliteDef.columns.metadata.columnType).toBe('text');
+            });
+        });
+    });
+});
+//# sourceMappingURL=table-def.test.js.map