@livestore/common 0.4.0-dev.21 → 0.4.0-dev.23

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

@@ -1,5 +1,8 @@
+import { objectToString } from '@livestore/utils'
+
 import { Schema } from '@livestore/utils/effect'
-import { describe, expect, it } from 'vitest'
+import { describe, expect, expectTypeOf, it } from 'vitest'
+
 import { State } from '../../mod.ts'
 
 describe('table function overloads', () => {
@@ -79,11 +82,11 @@ 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(objectToString(todosTable.sqliteDef.columns.optionalBoolean.schema)).toBe('(number <-> boolean) | null')
     expect((todosTable.rowSchema as any).fields.optionalBoolean.toString()).toBe('(number <-> boolean) | null')
 
     expect(todosTable.sqliteDef.columns.optionalComplex.nullable).toBe(true)
-    expect(todosTable.sqliteDef.columns.optionalComplex.schema.toString()).toBe(
+    expect(objectToString(todosTable.sqliteDef.columns.optionalComplex.schema)).toBe(
       '(parseJson <-> { readonly color: string } | undefined) | null',
     )
     expect((todosTable.rowSchema as any).fields.optionalComplex.toString()).toBe(
@@ -91,6 +94,22 @@ describe('table function overloads', () => {
     )
   })
 
+  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,
@@ -301,6 +320,50 @@ describe('table function overloads', () => {
     expect(userTable.sqliteDef.columns.metadata.nullable).toBe(true)
   })
 
+  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.Number,
@@ -327,7 +390,7 @@ describe('table function overloads', () => {
 
     expect(shapes.sqliteDef.columns.kind.columnType).toBe('text')
 
-    const kindSchema = shapes.sqliteDef.columns.kind.schema.toString()
+    const kindSchema = objectToString(shapes.sqliteDef.columns.kind.schema)
     expect(kindSchema).toContain('"circle" | "square"')
 
     expect(() =>

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

@@ -168,10 +168,7 @@ export function table<
     name: TName
     schema: TSchema
   } & Partial<TOptionsInput>,
-): TableDef<
-  SqliteTableDefForSchemaInput<TName, Schema.Schema.Type<TSchema>, Schema.Schema.Encoded<TSchema>, TSchema>,
-  TableOptions
->
+): TableDef<SqliteTableDefForSchemaInput<TName, Schema.Schema.Type<TSchema>, Schema.Schema.Encoded<TSchema>, TSchema>>
 
 // Overload 3: With schema and no name (uses schema annotations)
 export function table<
@@ -181,10 +178,7 @@ export function table<
   args: {
     schema: TSchema
   } & Partial<TOptionsInput>,
-): TableDef<
-  SqliteTableDefForSchemaInput<string, Schema.Schema.Type<TSchema>, Schema.Schema.Encoded<TSchema>, TSchema>,
-  TableOptions
->
+): TableDef<SqliteTableDefForSchemaInput<string, Schema.Schema.Type<TSchema>, Schema.Schema.Encoded<TSchema>, TSchema>>
 
 // Implementation
 export function table<
@@ -216,9 +210,7 @@ export function table<
   if ('columns' in args) {
     tableName = args.name
     const columnOrColumns = args.columns
-    columns = (
-      SqliteDsl.isColumnDefinition(columnOrColumns) ? { value: columnOrColumns } : columnOrColumns
-    ) as SqliteDsl.Columns
+    columns = SqliteDsl.isColumnDefinition(columnOrColumns) === true ? { value: columnOrColumns } : columnOrColumns
     additionalIndexes = []
   } else if ('schema' in args) {
     const result = schemaFieldsToColumns(Schema.getResolvedPropertySignatures(args.schema))
@@ -377,15 +369,16 @@ export type ToColumns<TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefin
       : never
 
 export declare namespace SchemaToColumns {
+  /** Checks if `null` or `undefined` is assignable to `T`, matching the runtime nullable detection. */
+  type IsNullable<T> = null extends T ? true : undefined extends T ? true : false
+
   // Type helper to create column definition with proper schema
-  export type ColumnDefForType<TEncoded, TType> = SqliteDsl.ColumnDefinition<TEncoded, TType>
+  export type ColumnDefForType<TEncoded, TType> = SqliteDsl.ColumnDefinition<TEncoded, TType, IsNullable<TEncoded>>
 
-  // Create columns type from schema Type and Encoded
   export type FromTypes<TType, TEncoded> =
     TEncoded extends Record<string, any>
       ? {
-          [K in keyof TEncoded]-?: ColumnDefForType<
-            TEncoded[K],
+          [K in keyof TEncoded]-?: ColumnDefForType<TEncoded[K],
             TType extends Record<string, any> ? (K extends keyof TType ? TType[K] : TEncoded[K]) : TEncoded[K]
           >
         }

package/src/schema/unknown-events.ts

@@ -17,7 +17,7 @@ export namespace UnknownEvents {
   export type Callback = (
     context: UnknownEventContext,
     error: UnknownEventError,
-  ) => Effect.SyncOrPromiseOrEffect<void, unknown, never>
+  ) => Effect.SyncOrPromiseOrEffect<void, unknown>
 
   export type HandlingConfig =
     | { readonly strategy: 'warn' }
@@ -60,7 +60,7 @@ const handleUnknownEvent = ({
 
     switch (config.strategy) {
       case 'fail': {
-        return yield* Effect.fail(error)
+        return yield* error
       }
       case 'warn': {
         yield* Effect.logWarning('@livestore/common:schema:unknown-event', context)

package/src/schema-management/__tests__/migrations-autoincrement-quoting.test.ts

@@ -1,5 +1,7 @@
-import { Effect, Option, Schema } from '@livestore/utils/effect'
 import { describe, expect, it } from 'vitest'
+
+import { Effect, Option, Schema } from '@livestore/utils/effect'
+
 import { SqliteAst } from '../../schema/state/sqlite/db-schema/mod.ts'
 import type { PreparedStatement, SqliteDb } from '../../sqlite-types.ts'
 import type { PreparedBindValues } from '../../util.ts'

package/src/schema-management/common.ts

@@ -13,7 +13,7 @@ export const dbExecute = (db: SqliteDb, queryStr: string, bindValues?: ParamsObj
   // cachedStmts.set(queryStr, stmt)
   // }
 
-  const preparedBindValues = bindValues ? prepareBindValues(bindValues, queryStr) : undefined
+  const preparedBindValues = bindValues !== undefined ? prepareBindValues(bindValues, queryStr) : undefined
 
   try {
     stmt.execute(preparedBindValues)
@@ -34,7 +34,7 @@ export const dbSelect = <T>(db: SqliteDb, queryStr: string, bindValues?: ParamsO
   // cachedStmts.set(queryStr, stmt)
   // }
 
-  const res = stmt.select<T>(bindValues ? prepareBindValues(bindValues, queryStr) : undefined)
+  const res = stmt.select<T>(bindValues !== undefined ? prepareBindValues(bindValues, queryStr) : undefined)
   stmt.finalize()
   return res
 }

package/src/schema-management/migrations.ts

@@ -200,7 +200,7 @@ export const migrateTable = ({
   )
 
 const createIndexFromDefinition = (tableName: string, index: SqliteAst.Index) => {
-  const uniqueStr = index.unique ? 'UNIQUE' : ''
+  const uniqueStr = index.unique === true ? 'UNIQUE' : ''
   return sql`create ${uniqueStr} index if not exists "${index.name}" on "${tableName}" (${index.columns
     .map((col) => `"${col}"`)
     .join(', ')})`

package/src/sql-queries/sql-queries.ts

@@ -23,7 +23,7 @@ export const findManyRows = <TColumns extends SqliteDsl.Columns>({
 }): [string, BindValues] => {
   const whereSql = buildWhereSql({ where })
   const whereModifier = whereSql === '' ? '' : `WHERE ${whereSql}`
-  const limitModifier = limit ? `LIMIT ${limit}` : ''
+  const limitModifier = limit !== undefined ? `LIMIT ${limit}` : ''
 
   const whereBindValues = makeBindValues({ columns, values: where, variablePrefix: 'where_', skipNil: true })
 
@@ -80,7 +80,7 @@ export const insertRowPrepared = <TColumns extends SqliteDsl.Columns>({
   const keysStr = keys.join(', ')
   const valuesStr = keys.map((key) => `$${key}`).join(', ')
 
-  return sql`INSERT ${options.orReplace ? 'OR REPLACE ' : ''}INTO ${tableName} (${keysStr}) VALUES (${valuesStr})`
+  return sql`INSERT ${options.orReplace === true ? 'OR REPLACE ' : ''}INTO ${tableName} (${keysStr}) VALUES (${valuesStr})`
 }
 
 export const insertRows = <TColumns extends SqliteDsl.Columns>({
@@ -134,7 +134,7 @@ export const insertOrIgnoreRow = <TColumns extends SqliteDsl.Columns>({
     .join(', ')
 
   const bindValues = makeBindValues({ columns, values })
-  const returningStmt = returnRow ? 'RETURNING *' : ''
+  const returningStmt = returnRow === true ? 'RETURNING *' : ''
 
   return [sql`INSERT OR IGNORE INTO ${tableName} (${keysStr}) VALUES (${valuesStr}) ${returningStmt}`, bindValues]
 }
@@ -251,7 +251,7 @@ export const createTable = ({
       if (columnDef.default._tag === 'None') return ''
       const defaultValue = columnDef.default.value
       if (typeof defaultValue === 'function') return ''
-      if (defaultValue && typeof defaultValue === 'object' && 'sql' in defaultValue) {
+      if (defaultValue !== undefined && typeof defaultValue === 'object' && 'sql' in defaultValue) {
         return `DEFAULT ${defaultValue.sql}`
       }
       return `DEFAULT ${defaultValue}`
@@ -301,7 +301,7 @@ Error: ${parseErrorStr}
 Value:`,
             value,
           )
-          // biome-ignore lint/suspicious/noDebugger: debug
+          // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint for SQL decode errors
           debugger
           throw res.left
         } else {
@@ -349,7 +349,11 @@ const buildWhereSql = <TColumns extends SqliteDsl.Columns>({
   const getWhereOp = (columnName: string, value: ClientTypes.WhereValueForDecoded<any>) => {
     if (value === null) {
       return `IS NULL`
-    } else if (typeof value === 'object' && typeof value.op === 'string' && ClientTypes.isValidWhereOp(value.op)) {
+    } else if (
+      typeof value === 'object' &&
+      typeof value.op === 'string' &&
+      ClientTypes.isValidWhereOp(value.op) === true
+    ) {
       return `${value.op} $where_${columnName}`
     } else if (typeof value === 'object' && typeof value.op === 'string' && value.op === 'in') {
       return `in (${value.val.map((_: any, i: number) => `$where_${columnName}_${i}`).join(', ')})`

package/src/sql-queries/sql-query-builder.ts

@@ -1,4 +1,5 @@
 import { omitUndefineds } from '@livestore/utils'
+
 import type { SqliteDsl } from '../schema/state/sqlite/db-schema/mod.ts'
 import type { BindValues } from './sql-queries.ts'
 import * as SqlQueries from './sql-queries.ts'

package/src/sqlite-db-helper.ts

@@ -14,7 +14,7 @@ export const makeExecute = (
   return (...args: any[]) => {
     const [queryStrOrQueryBuilder, bindValuesOrOptions, maybeOptions] = args
 
-    if (isQueryBuilder(queryStrOrQueryBuilder)) {
+    if (isQueryBuilder(queryStrOrQueryBuilder) === true) {
       const { query, bindValues } = queryStrOrQueryBuilder.asSql()
       return execute(query, bindValues as unknown as PreparedBindValues, bindValuesOrOptions)
     } else {
@@ -29,7 +29,7 @@ export const makeSelect = <T>(
   return (...args: any[]) => {
     const [queryStrOrQueryBuilder, maybeBindValues] = args
 
-    if (isQueryBuilder(queryStrOrQueryBuilder)) {
+    if (isQueryBuilder(queryStrOrQueryBuilder) === true) {
       const { query, bindValues } = queryStrOrQueryBuilder.asSql()
       const resultSchema = getResultSchema(queryStrOrQueryBuilder)
       const results = select(query, bindValues as unknown as PreparedBindValues)
@@ -44,7 +44,7 @@ export const validateSnapshot = (snapshot: Uint8Array) => {
   const headerBytes = new TextDecoder().decode(snapshot.slice(0, 16))
   const hasValidHeader = headerBytes.startsWith('SQLite format 3')
 
-  if (!hasValidHeader) {
+  if (hasValidHeader === false) {
     throw new SqliteError({
       cause: 'Invalid SQLite header',
       note: `Expected header to start with 'SQLite format 3', but got: ${headerBytes}`,

package/src/sqlite-types.ts

@@ -1,4 +1,5 @@
 import { type Effect, Schema } from '@livestore/utils/effect'
+
 import type { SqliteError, UnknownError } from './errors.ts'
 import type { EventSequenceNumber } from './schema/mod.ts'
 import type { QueryBuilder } from './schema/state/sqlite/query-builder/api.ts'
@@ -17,12 +18,12 @@ export interface SqliteDb<TReq = any, TMetadata extends TReq = TReq> {
   prepare(queryStr: string): PreparedStatement
   execute(
     queryStr: string,
-    bindValues?: PreparedBindValues | undefined,
+    bindValues?: PreparedBindValues  ,
     options?: { onRowsChanged?: (rowsChanged: number) => void },
   ): void
   execute(queryBuilder: QueryBuilder.Any, options?: { onRowsChanged?: (rowsChanged: number) => void }): void
 
-  select<T>(queryStr: string, bindValues?: PreparedBindValues | undefined): ReadonlyArray<T>
+  select<T>(queryStr: string, bindValues?: PreparedBindValues  ): ReadonlyArray<T>
   select<T>(queryBuilder: QueryBuilder<T, any, any>): T
 
   export(): Uint8Array<ArrayBuffer>