@livestore/common 0.4.0-dev.15 → 0.4.0-dev.17

package/src/schema/state/sqlite/column-spec.ts

@@ -47,11 +47,16 @@ const toSqliteColumnSpec = (column: SqliteAst.Column, opts: { inlinePrimaryKey:
   const defaultValueStr = (() => {
     if (column.default._tag === 'None') return ''
 
-    if (column.default.value === null) return 'default null'
-    if (SqliteDsl.isSqlDefaultValue(column.default.value)) return `default ${column.default.value.sql}`
+    const defaultValue = column.default.value
+    if (SqliteDsl.isDefaultThunk(defaultValue)) return ''
+
+    const resolvedDefault = SqliteDsl.resolveColumnDefault(defaultValue)
+
+    if (resolvedDefault === null) return 'default null'
+    if (SqliteDsl.isSqlDefaultValue(resolvedDefault)) return `default ${resolvedDefault.sql}`
 
     const encodeValue = Schema.encodeSync(column.schema)
-    const encodedDefaultValue = encodeValue(column.default.value)
+    const encodedDefaultValue = encodeValue(resolvedDefault)
 
     if (columnTypeStr === 'text') return `default '${encodedDefaultValue}'`
     return `default ${encodedDefaultValue}`

package/src/schema/state/sqlite/db-schema/dsl/field-defs.ts

@@ -1,10 +1,27 @@
 import { casesHandled } from '@livestore/utils'
 import { Option, Schema } from '@livestore/utils/effect'
 
+export type SqlDefaultValue = {
+  readonly sql: string
+}
+
+export const isSqlDefaultValue = (value: unknown): value is SqlDefaultValue => {
+  return typeof value === 'object' && value !== null && 'sql' in value && typeof (value as any).sql === 'string'
+}
+
+export type ColumnDefaultThunk<T> = () => T
+
+export const isDefaultThunk = (value: unknown): value is ColumnDefaultThunk<unknown> => typeof value === 'function'
+
+export type ColumnDefaultValue<T> = T | null | ColumnDefaultThunk<T | null> | SqlDefaultValue
+
+export const resolveColumnDefault = <T>(value: ColumnDefaultValue<T>): T | null | SqlDefaultValue =>
+  isDefaultThunk(value) ? (value as ColumnDefaultThunk<T | null>)() : value
+
 export type ColumnDefinition<TEncoded, TDecoded> = {
   readonly columnType: FieldColumnType
   readonly schema: Schema.Schema<TDecoded, TEncoded>
-  readonly default: Option.Option<TEncoded>
+  readonly default: Option.Option<ColumnDefaultValue<TDecoded>>
   /** @default false */
   readonly nullable: boolean
   /** @default false */
@@ -27,9 +44,17 @@ export const isColumnDefinition = (value: unknown): value is ColumnDefinition.An
   )
 }
 
+type MaybeNull<T, TNullable extends boolean> = T | (TNullable extends true ? null : never)
+
+type ColumnDefaultArg<T, TNullable extends boolean> =
+  | MaybeNull<T, TNullable>
+  | ColumnDefaultThunk<MaybeNull<T, TNullable>>
+  | SqlDefaultValue
+  | NoDefault
+
 export type ColumnDefinitionInput = {
   readonly schema?: Schema.Schema<unknown>
-  readonly default?: unknown | NoDefault
+  readonly default?: ColumnDefaultArg<unknown, boolean>
   readonly nullable?: boolean
   readonly primaryKey?: boolean
   readonly autoIncrement?: boolean
@@ -38,14 +63,6 @@ export type ColumnDefinitionInput = {
 export const NoDefault = Symbol.for('NoDefault')
 export type NoDefault = typeof NoDefault
 
-export type SqlDefaultValue = {
-  readonly sql: string
-}
-
-export const isSqlDefaultValue = (value: unknown): value is SqlDefaultValue => {
-  return typeof value === 'object' && value !== null && 'sql' in value && typeof value.sql === 'string'
-}
-
 export type ColDefFn<TColumnType extends FieldColumnType> = {
   (): {
     columnType: TColumnType
@@ -59,7 +76,7 @@ export type ColDefFn<TColumnType extends FieldColumnType> = {
     TEncoded extends DefaultEncodedForColumnType<TColumnType>,
     TDecoded = DefaultEncodedForColumnType<TColumnType>,
     const TNullable extends boolean = false,
-    const TDefault extends TDecoded | SqlDefaultValue | NoDefault | (TNullable extends true ? null : never) = NoDefault,
+    const TDefault extends ColumnDefaultArg<NoInfer<TDecoded>, TNullable> = NoDefault,
     const TPrimaryKey extends boolean = false,
     const TAutoIncrement extends boolean = false,
   >(args: {
@@ -132,7 +149,7 @@ export type SpecializedColDefFn<
   <
     TDecoded = TBaseDecoded,
     const TNullable extends boolean = false,
-    const TDefault extends TDecoded | NoDefault | (TNullable extends true ? null : never) = NoDefault,
+    const TDefault extends ColumnDefaultArg<NoInfer<TDecoded>, TNullable> = NoDefault,
     const TPrimaryKey extends boolean = false,
     const TAutoIncrement extends boolean = false,
   >(

package/src/schema/state/sqlite/schema-helpers.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest'
+
+import * as State from '../mod.ts'
+import { getDefaultValuesDecoded, getDefaultValuesEncoded } from './schema-helpers.ts'
+
+describe('schema-helpers', () => {
+  it('resolves thunk defaults when decoding values', () => {
+    let counter = 0
+    const table = State.SQLite.table({
+      name: 'sessions',
+      columns: {
+        id: State.SQLite.text({ primaryKey: true }),
+        token: State.SQLite.text({ default: () => `token-${++counter}` }),
+      },
+    })
+
+    expect(counter).toBe(0)
+
+    const firstDefaults = getDefaultValuesDecoded(table)
+    const secondDefaults = getDefaultValuesDecoded(table)
+
+    expect(firstDefaults.token).toBe('token-1')
+    expect(secondDefaults.token).toBe('token-2')
+  })
+
+  it('resolves thunk defaults when encoding values', () => {
+    let counter = 0
+    const table = State.SQLite.table({
+      name: 'sessions_encoded',
+      columns: {
+        id: State.SQLite.text({ primaryKey: true }),
+        token: State.SQLite.text({ default: () => `encoded-${++counter}` }),
+      },
+    })
+
+    expect(counter).toBe(0)
+
+    const firstDefaults = getDefaultValuesEncoded(table)
+    const secondDefaults = getDefaultValuesEncoded(table)
+
+    expect(firstDefaults.token).toBe('encoded-1')
+    expect(secondDefaults.token).toBe('encoded-2')
+  })
+})

package/src/schema/state/sqlite/schema-helpers.ts

@@ -2,9 +2,9 @@ import { shouldNeverHappen } from '@livestore/utils'
 import { pipe, ReadonlyRecord, Schema } from '@livestore/utils/effect'
 
 import { SqliteDsl } from './db-schema/mod.ts'
-import type { TableDef, TableDefBase } from './table-def.ts'
+import type { TableDefBase } from './table-def.ts'
 
-export const getDefaultValuesEncoded = <TTableDef extends TableDef>(
+export const getDefaultValuesEncoded = <TTableDef extends TableDefBase>(
   tableDef: TTableDef,
   fallbackValues?: Record<string, any>,
 ) =>
@@ -15,15 +15,19 @@ export const getDefaultValuesEncoded = <TTableDef extends TableDef>(
       if (key === 'id') return false
       return col!.default._tag === 'None' || SqliteDsl.isSqlDefaultValue(col!.default.value) === false
     }),
-    ReadonlyRecord.map((column, columnName) =>
-      fallbackValues?.[columnName] === undefined
-        ? column!.default._tag === 'None'
-          ? column!.nullable === true
-            ? null
-            : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
-          : Schema.encodeSync(column!.schema)(column!.default.value)
-        : fallbackValues[columnName],
-    ),
+    ReadonlyRecord.map((column, columnName) => {
+      if (fallbackValues?.[columnName] !== undefined) return fallbackValues[columnName]
+      if (column!.default._tag === 'None') {
+        return column!.nullable === true
+          ? null
+          : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
+      }
+
+      const defaultValue = column!.default.value
+      const resolvedDefault = SqliteDsl.resolveColumnDefault(defaultValue)
+
+      return Schema.encodeSync(column!.schema)(resolvedDefault)
+    }),
   )
 
 export const getDefaultValuesDecoded = <TTableDef extends TableDefBase>(
@@ -37,13 +41,17 @@ export const getDefaultValuesDecoded = <TTableDef extends TableDefBase>(
       if (key === 'id') return false
       return col!.default._tag === 'None' || SqliteDsl.isSqlDefaultValue(col!.default.value) === false
     }),
-    ReadonlyRecord.map((column, columnName) =>
-      fallbackValues?.[columnName] === undefined
-        ? column!.default._tag === 'None'
-          ? column!.nullable === true
-            ? null
-            : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
-          : Schema.validateSync(column!.schema)(column!.default.value)
-        : fallbackValues[columnName],
-    ),
+    ReadonlyRecord.map((column, columnName) => {
+      if (fallbackValues?.[columnName] !== undefined) return fallbackValues[columnName]
+      if (column!.default._tag === 'None') {
+        return column!.nullable === true
+          ? null
+          : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
+      }
+
+      const defaultValue = column!.default.value
+      const resolvedDefault = SqliteDsl.resolveColumnDefault(defaultValue)
+
+      return Schema.validateSync(column!.schema)(resolvedDefault)
+    }),
   )

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

@@ -247,7 +247,15 @@ export const createTable = ({
     .map(([columnName, _]) => columnName)
   const columnDefStrs = Object.entries(table.columns).map(([columnName, columnDef]) => {
     const nullModifier = columnDef.nullable === true ? '' : 'NOT NULL'
-    const defaultModifier = columnDef.default._tag === 'None' ? '' : `DEFAULT ${columnDef.default.value}`
+    const defaultModifier = (() => {
+      if (columnDef.default._tag === 'None') return ''
+      const defaultValue = columnDef.default.value
+      if (typeof defaultValue === 'function') return ''
+      if (defaultValue && typeof defaultValue === 'object' && 'sql' in defaultValue) {
+        return `DEFAULT ${defaultValue.sql}`
+      }
+      return `DEFAULT ${defaultValue}`
+    })()
     return sql`${columnName} ${columnDef.columnType} ${nullModifier} ${defaultModifier}`
   })
 

package/src/version.ts

@@ -2,7 +2,7 @@
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
 
-export const liveStoreVersion = '0.4.0-dev.15' as const
+export const liveStoreVersion = '0.4.0-dev.17' as const
 
 /**
  * CRITICAL: Increment this version whenever you modify client-side EVENTLOG table schemas.