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

package/dist/version.js

@@ -1,7 +1,7 @@
 // TODO bring back when Expo and Playwright supports `with` imports
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
-export const liveStoreVersion = '0.4.0-dev.15';
+export const liveStoreVersion = '0.4.0-dev.16';
 /**
  * CRITICAL: Increment this version whenever you modify client-side EVENTLOG table schemas.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/common",
-  "version": "0.4.0-dev.15",
+  "version": "0.4.0-dev.16",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -15,12 +15,12 @@
   },
   "dependencies": {
     "@opentelemetry/api": "1.9.0",
-    "@livestore/utils": "0.4.0-dev.15",
-    "@livestore/webmesh": "0.4.0-dev.15"
+    "@livestore/utils": "0.4.0-dev.16",
+    "@livestore/webmesh": "0.4.0-dev.16"
   },
   "devDependencies": {
     "vitest": "3.2.4",
-    "@livestore/utils-dev": "0.4.0-dev.15"
+    "@livestore/utils-dev": "0.4.0-dev.16"
   },
   "files": [
     "package.json",

package/src/devtools/devtools-sessioninfo.ts

@@ -61,7 +61,7 @@ export const requestSessionInfoSubscription = ({
   webChannel: WebChannel.WebChannel<Message, Message>
   pollInterval?: Duration.DurationInput
   staleTimeout?: Duration.DurationInput
-}): Effect.Effect<Subscribable.Subscribable<Set<SessionInfo>>, ParseResult.ParseError, Scope.Scope> =>
+}): Effect.Effect<Subscribable.Subscribable<HashSet.HashSet<SessionInfo>>, ParseResult.ParseError, Scope.Scope> =>
   Effect.gen(function* () {
     yield* webChannel
       .send(RequestSessions.make({}))
@@ -100,8 +100,5 @@ export const requestSessionInfoSubscription = ({
       Effect.forkScoped,
     )
 
-    return Subscribable.make({
-      get: sessionInfoSubRef.get.pipe(Effect.map((sessionInfos) => new Set(sessionInfos))),
-      changes: sessionInfoSubRef.changes.pipe(Stream.map((sessionInfos) => new Set(sessionInfos))),
-    })
+    return Subscribable.make({ get: sessionInfoSubRef.get, changes: sessionInfoSubRef.changes })
   })

package/src/index.ts

@@ -2,6 +2,7 @@ export * from './adapter-types.ts'
 export * from './bounded-collections.ts'
 export * from './debug-info.ts'
 export * as Devtools from './devtools/mod.ts'
+export * as LogConfig from './logging.ts'
 export * from './make-client-session.ts'
 export * from './materializer-helper.ts'
 export * from './otel.ts'

package/src/logging.ts

@@ -0,0 +1,62 @@
+import { isDevEnv } from '@livestore/utils'
+import { Effect, type Layer, Logger, LogLevel } from '@livestore/utils/effect'
+
+/**
+ * Optional Effect logger configuration that LiveStore entry points accept.
+ *
+ * When provided, `logger` replaces the default pretty logger for the runtime.
+ * Use `logLevel` to control verbosity. Set to `LogLevel.None` to disable logging
+ * entirely while keeping the same logger implementation.
+ */
+export type WithLoggerOptions = {
+  /** Optional Effect logger layer to control logging output. */
+  logger?: Layer.Layer<never> | undefined
+  /** Optional minimum log level for the runtime. */
+  logLevel?: LogLevel.LogLevel | undefined
+}
+
+/**
+ * Common defaults for resolving a logger configuration.
+ * - `threadName` is used by the default pretty logger when `logger` is not provided.
+ * - `mode` selects pretty logger mode (e.g. 'browser' for web workers).
+ * - `defaultLogLevel` is used when `logLevel` is not provided.
+ */
+export type LoggerDefaults = {
+  threadName?: string
+  mode?: 'tty' | 'browser'
+  defaultLogLevel?: LogLevel.LogLevel
+  /** Optional default logger layer to use when `config.logger` is not provided. */
+  defaultLogger?: Layer.Layer<never>
+}
+
+/**
+ * Resolve the logger layer to provide to the Effect runtime.
+ */
+export const resolveLoggerLayer = (config?: WithLoggerOptions, defaults?: LoggerDefaults): Layer.Layer<never> => {
+  if (config?.logger) return config.logger
+  if (defaults?.defaultLogger) return defaults.defaultLogger
+  const threadName = defaults?.threadName ?? 'livestore'
+  const mode = defaults?.mode
+  return Logger.prettyWithThread(threadName, mode ? { mode } : {})
+}
+
+/**
+ * Resolve the minimum log level, falling back to `defaults.defaultLogLevel` then `LogLevel.Debug`.
+ */
+export const resolveLogLevel = (config?: WithLoggerOptions, defaults?: LoggerDefaults): LogLevel.LogLevel => {
+  if (config?.logLevel !== undefined) return config.logLevel
+  if (defaults?.defaultLogLevel !== undefined) return defaults.defaultLogLevel
+  return isDevEnv() ? LogLevel.Debug : LogLevel.Info
+}
+
+/**
+ * Wrap an effect by applying the resolved minimum log level and providing the resolved logger layer.
+ */
+export const withLoggerConfig = <TEnv, TError, TOut>(
+  config?: WithLoggerOptions,
+  defaults?: LoggerDefaults,
+): ((effect: Effect.Effect<TOut, TError, TEnv>) => Effect.Effect<TOut, TError, TEnv>) => {
+  const level = resolveLogLevel(config, defaults)
+  const layer = resolveLoggerLayer(config, defaults)
+  return (effect) => effect.pipe(Logger.withMinimumLogLevel(level), Effect.provide(layer))
+}

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

@@ -1,5 +1,5 @@
 import { Schema } from '@livestore/utils/effect'
-import { describe, expect, it } from 'vitest'
+import { assert, describe, expect, it } from 'vitest'
 
 import * as State from '../mod.ts'
 import { withAutoIncrement, withColumnType, withDefault, withPrimaryKey, withUnique } from './column-annotations.ts'
@@ -636,6 +636,29 @@ describe('getColumnDefForSchema', () => {
           table2.sqliteDef.columns.count.default._tag === 'Some' && table2.sqliteDef.columns.count.default.value,
         ).toBe(0)
       })
+
+      it('should support thunk defaults without eager evaluation', () => {
+        let counter = 0
+        const UserSchema = Schema.Struct({
+          id: Schema.String.pipe(
+            withDefault(() => {
+              counter += 1
+              return `user-${counter}`
+            }),
+          ),
+        })
+
+        const table = State.SQLite.table({ name: 'users_with_thunk', schema: UserSchema })
+
+        expect(counter).toBe(0)
+        expect(table.sqliteDef.columns.id.default._tag).toBe('Some')
+        if (table.sqliteDef.columns.id.default._tag === 'Some') {
+          const defaultThunk = table.sqliteDef.columns.id.default.value
+          assert(typeof defaultThunk === 'function')
+          expect(defaultThunk()).toBe('user-1')
+          expect(defaultThunk()).toBe('user-2')
+        }
+      })
     })
 
     describe('withUnique', () => {

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

@@ -146,6 +146,22 @@ describe('makeColumnSpec', () => {
     expect(result).toContain('default RANDOM()')
   })
 
+  it('should omit default clause for thunk defaults', () => {
+    const table = SqliteAst.table(
+      'thunks',
+      [
+        createColumn('id', 'integer', { nullable: false, primaryKey: true }),
+        createColumn('token', 'text', { defaultValue: () => 'dynamic-token' }),
+      ],
+      [],
+    )
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(`""id" integer primary key   , "token" text    "`)
+    expect(result).not.toContain('dynamic-token')
+    expect(result).not.toMatch(/token" text\s+default/i)
+  })
+
   it('should handle null default values', () => {
     const table = SqliteAst.table(
       'nullable_defaults',

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.16' as const
 
 /**
  * CRITICAL: Increment this version whenever you modify client-side EVENTLOG table schemas.