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

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

@@ -1,5 +1,8 @@
-import { Schema } from '@livestore/utils/effect'
-import { describe, expect, it } from 'vitest'
+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', () => {
@@ -8,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,
@@ -22,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 })
 
@@ -34,7 +37,7 @@ describe('table function overloads', () => {
       id: Schema.String,
       text: Schema.String,
       completed: Schema.Boolean,
-    }).annotations({
+    }).annotate({
       title: 'todos',
       identifier: 'TodoItem',
     })
@@ -56,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: {
@@ -71,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')
@@ -79,18 +81,61 @@ describe('table function overloads', () => {
     expect(todosTable.sqliteDef.columns).toHaveProperty('optionalComplex')
 
     expect(todosTable.sqliteDef.columns.optionalBoolean.nullable).toBe(true)
-    expect(todosTable.sqliteDef.columns.optionalBoolean.schema.toString()).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(todosTable.sqliteDef.columns.optionalComplex.schema.toString()).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,
+      },
     )
   })
 
+  it('should allow explicit first two generic arguments without options generic', () => {
+    const columns = {
+      id: State.SQLite.text({ primaryKey: true }),
+      text: State.SQLite.text({ default: '' }),
+    }
+
+    const todosTable = State.SQLite.table<'todos', typeof columns>({
+      name: 'todos',
+      columns,
+    })
+
+    expect(todosTable.sqliteDef.name).toBe('todos')
+    expect(todosTable.sqliteDef.columns).toHaveProperty('id')
+    expect(todosTable.sqliteDef.columns).toHaveProperty('text')
+  })
+
   it('should work with schema parameter', () => {
     const TodoSchema = Schema.Struct({
       id: Schema.String,
@@ -186,32 +231,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({
@@ -247,13 +293,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({
@@ -278,13 +324,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'
@@ -299,5 +338,215 @@ 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()', () => {
+    const UserSchema = Schema.Struct({
+      id: Schema.String.pipe(State.SQLite.withPrimaryKey),
+      undefined: Schema.Undefined,
+      null: Schema.Null,
+      undefinedOrString: Schema.UndefinedOr(Schema.String),
+      nullOrString: Schema.NullOr(Schema.String),
+      optionalString: Schema.optional(Schema.String),
+      optionalNullOrString: Schema.optional(Schema.NullOr(Schema.String)),
+    })
+
+    const usersTable = State.SQLite.table({
+      name: 'users',
+      schema: UserSchema,
+    })
+
+    // Non-nullable fields (id) are required — omitting id should be rejected
+    expectTypeOf<{ undefined: undefined }>().not.toExtend<Parameters<typeof usersTable.insert>[0]>()
+
+    // Nullable fields (NullOr, optional+NullOr) are omittable — SQL defaults to NULL
+    expectTypeOf(usersTable.insert)
+      .toBeCallableWith({ id: '1' })
+      .toBeCallableWith({ id: '1', undefined: undefined })
+      .toBeCallableWith({ id: '1', undefined: undefined, null: null })
+      .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',
+      })
+
+    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()
+  })
+
+  it('supports discriminated unions with parsed JSON payloads', () => {
+    const CircleDataSchema = Schema.Struct({
+      radius: Schema.Finite,
+    })
+    const CircleSchema = Schema.Struct({
+      kind: Schema.Literal('circle'),
+      data: Schema.fromJsonString(CircleDataSchema),
+    })
+
+    const SquareDataSchema = Schema.Struct({
+      sideLength: Schema.Finite,
+    })
+    const SquareSchema = Schema.Struct({
+      kind: Schema.Literal('square'),
+      data: Schema.fromJsonString(SquareDataSchema),
+    })
+
+    const ShapeSchema = Schema.Union([CircleSchema, SquareSchema])
+
+    const shapes = State.SQLite.table({
+      name: 'shapes',
+      schema: ShapeSchema,
+    })
+
+    expect(shapes.sqliteDef.columns.kind.columnType).toBe('text')
+    expect(SchemaAST.isUnion(Schema.toEncoded(shapes.sqliteDef.columns.kind.schema).ast)).toBe(true)
+
+    expect(() =>
+      shapes
+        .insert({
+          kind: 'square',
+          data: { sideLength: 10 },
+        })
+        .asSql(),
+    ).not.toThrow()
+
+    expect(() =>
+      shapes
+        .insert({
+          kind: 'circle',
+          data: { radius: 5 },
+        })
+        .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)
   })
 })