@livestore/common 0.4.0 → 0.5.0-dev.1

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

@@ -4,33 +4,52 @@ import { Schema } from '@livestore/utils/effect'
 
 import * as F from './field-defs.ts'
 
-describe.concurrent('FieldDefs', () => {
+describe('FieldDefs', () => {
   test('text', () => {
-    expect(F.text()).toMatchSnapshot()
-    expect(F.text({})).toMatchSnapshot()
-    expect(F.text({ default: null, nullable: true })).toMatchSnapshot()
-    expect(F.text({ schema: Schema.Literal('foo'), nullable: true, default: 'foo' })).toMatchSnapshot()
-    expect(F.text({ schema: Schema.Union(Schema.Literal('foo')), nullable: true, default: 'foo' })).toMatchSnapshot()
+    expect(columnDefSnapshot(F.text())).toMatchSnapshot()
+    expect(columnDefSnapshot(F.text({}))).toMatchSnapshot()
+    expect(columnDefSnapshot(F.text({ default: null, nullable: true }))).toMatchSnapshot()
+    expect(
+      columnDefSnapshot(F.text({ schema: Schema.Literal('foo'), nullable: true, default: 'foo' })),
+    ).toMatchSnapshot()
+    expect(
+      columnDefSnapshot(F.text({ schema: Schema.Union([Schema.Literal('foo')]), nullable: true, default: 'foo' })),
+    ).toMatchSnapshot()
   })
 
   test('json', () => {
-    expect(F.json()).toMatchSnapshot()
-    expect(F.json({ default: null, nullable: true })).toMatchSnapshot()
+    expect(columnDefSnapshot(F.json())).toMatchSnapshot()
+    expect(columnDefSnapshot(F.json({ default: null, nullable: true }))).toMatchSnapshot()
     expect(
-      F.json({ schema: Schema.Struct({ name: Schema.String }), default: { name: 'Bob' }, nullable: true }),
+      columnDefSnapshot(
+        F.json({ schema: Schema.Struct({ name: Schema.String }), default: { name: 'Bob' }, nullable: true }),
+      ),
     ).toMatchSnapshot()
   })
 
   test('datetime', () => {
-    expect(F.datetime()).toMatchSnapshot()
-    expect(F.datetime({})).toMatchSnapshot()
-    expect(F.datetime({ default: null, nullable: true })).toMatchSnapshot()
-    expect(F.datetime({ default: new Date('2022-02-02') })).toMatchSnapshot()
+    expect(columnDefSnapshot(F.datetime())).toMatchSnapshot()
+    expect(columnDefSnapshot(F.datetime({}))).toMatchSnapshot()
+    expect(columnDefSnapshot(F.datetime({ default: null, nullable: true }))).toMatchSnapshot()
+    expect(columnDefSnapshot(F.datetime({ default: new Date('2022-02-02') }))).toMatchSnapshot()
   })
 
   test('boolean', () => {
-    expect(F.boolean()).toMatchSnapshot()
-    expect(F.boolean({})).toMatchSnapshot()
-    expect(F.boolean({ default: false })).toMatchSnapshot()
+    expect(columnDefSnapshot(F.boolean())).toMatchSnapshot()
+    expect(columnDefSnapshot(F.boolean({}))).toMatchSnapshot()
+    expect(columnDefSnapshot(F.boolean({ default: false }))).toMatchSnapshot()
   })
 })
+
+const columnDefSnapshot = (columnDef: F.ColumnDefinition.Any) => ({
+  ...columnDef,
+  schema: schemaSnapshot(columnDef.schema),
+})
+
+// Effect schemas expose a large inspectable object graph. Snapshot only the
+// schema shape this DSL cares about.
+const schemaSnapshot = (schema: Schema.Codec<unknown, unknown>) => ({
+  ast: schema.ast._tag,
+  encodedAst: Schema.toEncoded(schema).ast._tag,
+  decodedAst: Schema.toType(schema).ast._tag,
+})

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

@@ -1,6 +1,8 @@
 import { casesHandled } from '@livestore/utils'
 import { Option, Schema } from '@livestore/utils/effect'
 
+import { SqliteReal } from '../../../../../util.ts'
+
 export type SqlDefaultValue = {
   readonly sql: string
 }
@@ -21,7 +23,7 @@ export const resolveColumnDefault = <T>(value: ColumnDefaultValue<T>): T | null
 
 export type ColumnDefinition<TEncoded, TDecoded, TNullable extends boolean = boolean> = {
   readonly columnType: FieldColumnType
-  readonly schema: Schema.Schema<TDecoded, TEncoded>
+  readonly schema: Schema.Codec<TDecoded, TEncoded>
   readonly default: Option.Option<ColumnDefaultValue<TDecoded>>
   /** @default false */
   readonly nullable: TNullable
@@ -55,7 +57,7 @@ type ColumnDefaultArg<T, TNullable extends boolean> =
   | NoDefault
 
 export type ColumnDefinitionInput = {
-  readonly schema?: Schema.Schema<unknown>
+  readonly schema?: Schema.Codec<unknown, unknown>
   readonly default?: ColumnDefaultArg<unknown, boolean>
   readonly nullable?: boolean
   readonly primaryKey?: boolean
@@ -68,7 +70,7 @@ export type NoDefault = typeof NoDefault
 export type ColDefFn<TColumnType extends FieldColumnType> = {
   (): {
     columnType: TColumnType
-    schema: Schema.Schema<DefaultEncodedForColumnType<TColumnType>>
+    schema: Schema.Codec<DefaultEncodedForColumnType<TColumnType>>
     default: Option.None<never>
     nullable: false
     primaryKey: false
@@ -82,7 +84,7 @@ export type ColDefFn<TColumnType extends FieldColumnType> = {
     const TPrimaryKey extends boolean = false,
     const TAutoIncrement extends boolean = false,
   >(args: {
-    schema?: Schema.Schema<TDecoded, TEncoded>
+    schema?: Schema.Codec<TDecoded, TEncoded>
     default?: TDefault
     nullable?: TNullable
     primaryKey?: TPrimaryKey
@@ -90,8 +92,8 @@ export type ColDefFn<TColumnType extends FieldColumnType> = {
   }): {
     columnType: TColumnType
     schema: TNullable extends true
-      ? Schema.Schema<NoInfer<TDecoded> | null, NoInfer<TEncoded> | null>
-      : Schema.Schema<NoInfer<TDecoded>, NoInfer<TEncoded>>
+      ? Schema.Codec<NoInfer<TDecoded> | null, NoInfer<TEncoded> | null>
+      : Schema.Codec<NoInfer<TDecoded>, NoInfer<TEncoded>>
     default: TDefault extends NoDefault ? Option.None<never> : Option.Some<NoInfer<TDefault>>
     nullable: NoInfer<TNullable>
     primaryKey: NoInfer<TPrimaryKey>
@@ -103,7 +105,7 @@ const makeColDef =
   <TColumnType extends FieldColumnType>(columnType: TColumnType): ColDefFn<TColumnType> =>
   (def?: ColumnDefinitionInput) => {
     const nullable = def?.nullable ?? false
-    const schemaWithoutNull: Schema.Schema<any> = def?.schema ?? defaultSchemaForColumnType(columnType)
+    const schemaWithoutNull = def?.schema ?? defaultSchemaForColumnType(columnType)
     const schema = nullable === true ? Schema.NullOr(schemaWithoutNull) : schemaWithoutNull
     const default_ = def?.default === undefined || def.default === NoDefault ? Option.none() : Option.some(def.default)
 
@@ -143,7 +145,7 @@ export type SpecializedColDefFn<
 > = {
   (): {
     columnType: TColumnType
-    schema: Schema.Schema<TBaseDecoded, DefaultEncodedForColumnType<TColumnType>>
+    schema: Schema.Codec<TBaseDecoded, DefaultEncodedForColumnType<TColumnType>>
     default: Option.None<never>
     nullable: false
     primaryKey: false
@@ -158,7 +160,7 @@ export type SpecializedColDefFn<
   >(
     args: TAllowsCustomSchema extends true
       ? {
-          schema?: Schema.Schema<TDecoded, any>
+          schema?: Schema.Codec<TDecoded, any>
           default?: TDefault
           nullable?: TNullable
           primaryKey?: TPrimaryKey
@@ -173,8 +175,8 @@ export type SpecializedColDefFn<
   ): {
     columnType: TColumnType
     schema: TNullable extends true
-      ? Schema.Schema<NoInfer<TDecoded> | null, DefaultEncodedForColumnType<TColumnType> | null>
-      : Schema.Schema<NoInfer<TDecoded>, DefaultEncodedForColumnType<TColumnType>>
+      ? Schema.Codec<NoInfer<TDecoded> | null, DefaultEncodedForColumnType<TColumnType> | null>
+      : Schema.Codec<NoInfer<TDecoded>, DefaultEncodedForColumnType<TColumnType>>
     default: TDefault extends NoDefault ? Option.None<never> : Option.Some<TDefault>
     nullable: NoInfer<TNullable>
     primaryKey: NoInfer<TPrimaryKey>
@@ -187,7 +189,7 @@ type MakeSpecializedColDefFn = {
     columnType: TColumnType,
     opts: {
       _tag: 'baseSchema'
-      baseSchema: Schema.Schema<TBaseDecoded, DefaultEncodedForColumnType<TColumnType>>
+      baseSchema: Schema.Codec<TBaseDecoded, DefaultEncodedForColumnType<TColumnType>>
     },
   ): SpecializedColDefFn<TColumnType, false, TBaseDecoded>
   <TColumnType extends FieldColumnType, TBaseDecoded>(
@@ -195,8 +197,8 @@ type MakeSpecializedColDefFn = {
     opts: {
       _tag: 'baseSchemaFn'
       baseSchemaFn: <TDecoded>(
-        customSchema: Schema.Schema<TDecoded, TBaseDecoded> | undefined,
-      ) => Schema.Schema<TBaseDecoded, DefaultEncodedForColumnType<TColumnType>>
+        customSchema: Schema.Codec<TDecoded, TBaseDecoded> | undefined,
+      ) => Schema.Codec<TBaseDecoded, DefaultEncodedForColumnType<TColumnType>>
     },
   ): SpecializedColDefFn<TColumnType, true, TBaseDecoded>
 }
@@ -221,28 +223,22 @@ const makeSpecializedColDef: MakeSpecializedColDefFn = (columnType, opts) => (de
 
 export const json: SpecializedColDefFn<'text', true, unknown> = makeSpecializedColDef('text', {
   _tag: 'baseSchemaFn',
-  baseSchemaFn: (customSchema) => Schema.parseJson(customSchema ?? Schema.Any),
+  baseSchemaFn: (customSchema) => Schema.fromJsonString(customSchema ?? Schema.Any),
 })
 
 export const datetime: SpecializedColDefFn<'text', false, Date> = makeSpecializedColDef('text', {
   _tag: 'baseSchema',
-  baseSchema: Schema.Date,
+  baseSchema: Schema.DateFromString,
 })
 
 export const datetimeInteger: SpecializedColDefFn<'integer', false, Date> = makeSpecializedColDef('integer', {
   _tag: 'baseSchema',
-  baseSchema: Schema.transform(Schema.Number, Schema.DateFromSelf, {
-    decode: (ms) => new Date(ms),
-    encode: (date) => date.getTime(),
-  }),
+  baseSchema: Schema.DateFromMillis,
 })
 
 export const boolean: SpecializedColDefFn<'integer', false, boolean> = makeSpecializedColDef('integer', {
   _tag: 'baseSchema',
-  baseSchema: Schema.transform(Schema.Number, Schema.Boolean, {
-    decode: (_) => _ === 1,
-    encode: (_) => (_ === true ? 1 : 0),
-  }),
+  baseSchema: Schema.BooleanFromBit,
 })
 
 export type FieldColumnType = 'text' | 'integer' | 'real' | 'blob'
@@ -257,27 +253,26 @@ export type DefaultEncodedForColumnType<TColumnType extends FieldColumnType> = T
         ? Uint8Array<ArrayBuffer>
         : never
 
-export const defaultSchemaForColumnType = <TColumnType extends FieldColumnType>(
-  columnType: TColumnType,
-): Schema.Schema<DefaultEncodedForColumnType<TColumnType>> => {
+export const defaultSchemaForColumnType = <TColumnType extends FieldColumnType>(columnType: TColumnType) => {
   type T = DefaultEncodedForColumnType<TColumnType>
 
   switch (columnType) {
     case 'text': {
       // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- switch-based type narrowing for column type to schema mapping; each case is correct for its branch
-      return Schema.String as any as Schema.Schema<T>
+      return Schema.String as Schema.Codec<T>
     }
     case 'integer': {
       // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- switch-based type narrowing for column type to schema mapping; each case is correct for its branch
-      return Schema.Number as any as Schema.Schema<T>
+      return Schema.Finite as Schema.Codec<T>
     }
     case 'real': {
       // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- switch-based type narrowing for column type to schema mapping; each case is correct for its branch
-      return Schema.Number as any as Schema.Schema<T>
+      // @effect-diagnostics-next-line schemaNumber:off -- SQLite REAL permits Infinity/NaN; SqliteReal is the documented domain carve-out
+      return SqliteReal as Schema.Codec<T>
     }
     case 'blob': {
       // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- switch-based type narrowing for column type to schema mapping; each case is correct for its branch
-      return Schema.Uint8ArrayFromSelf as any as Schema.Schema<T>
+      return Schema.Uint8Array as Schema.Codec<T>
     }
     default: {
       return casesHandled(columnType)

package/src/schema/state/sqlite/db-schema/dsl/mod.ts

@@ -1,7 +1,6 @@
 import type { Nullable } from '@livestore/utils'
 import { omitUndefineds } from '@livestore/utils'
-import type { Option, Types } from '@livestore/utils/effect'
-import { Schema } from '@livestore/utils/effect'
+import { type Option, Schema, Struct, type Types } from '@livestore/utils/effect'
 
 import type * as SqliteAst from '../ast/sqlite.ts'
 import type { ColumnDefinition } from './field-defs.ts'
@@ -52,26 +51,41 @@ export const table = <TTableName extends string, TColumns extends Columns, TInde
 export type AnyIfConstained<In, Out> = '__constrained' extends keyof In ? any : Out
 export type EmptyObjIfConstained<In> = '__constrained' extends keyof In ? {} : In
 
-export type StructSchemaForColumns<TCols extends ConstraintColumns> = Schema.Schema<
-  AnyIfConstained<TCols, FromColumns.RowDecoded<TCols>>,
-  AnyIfConstained<TCols, FromColumns.RowEncoded<TCols>>
->
+export type StructFieldsForColumns<TCols extends ConstraintColumns> = '__constrained' extends keyof TCols
+  ? Record<string, Schema.Codec<any, any>>
+  : { readonly [K in keyof TCols]: TCols[K]['schema'] }
+
+export type StructSchemaForColumns<TCols extends ConstraintColumns> = Schema.Struct<StructFieldsForColumns<TCols>>
 
-export type InsertStructSchemaForColumns<TCols extends ConstraintColumns> = Schema.Schema<
+export type InsertStructSchemaForColumns<TCols extends ConstraintColumns> = Schema.Codec<
   AnyIfConstained<TCols, FromColumns.InsertRowDecoded<TCols>>,
   AnyIfConstained<TCols, FromColumns.InsertRowEncoded<TCols>>
 >
 
-export const structSchemaForTable = <TTableDefinition extends TableDefinition<any, any>>(
-  tableDef: TTableDefinition,
-): StructSchemaForColumns<TTableDefinition['columns']> =>
-  Schema.Struct(Object.fromEntries(tableDef.ast.columns.map((column) => [column.name, column.schema]))).annotations({
+interface GetColumnSchema extends Struct.Lambda {
+  <TEncoded, TDecoded, TNullable extends boolean>(
+    column: ColumnDefinition<TEncoded, TDecoded, TNullable>,
+  ): ColumnDefinition<TEncoded, TDecoded, TNullable>['schema']
+  readonly '~lambda.out': this['~lambda.in'] extends ColumnDefinition<any, any, any>
+    ? this['~lambda.in']['schema']
+    : never
+}
+
+const getColumnSchema = Struct.lambda<GetColumnSchema>((column) => column.schema)
+
+const structFieldsForColumns = <TCols extends ConstraintColumns>(columns: TCols): StructFieldsForColumns<TCols> =>
+  Struct.map(columns, getColumnSchema)
+
+export const structSchemaForTable = <TTableName extends string, TColumns extends ConstraintColumns>(
+  tableDef: TableDefinition<TTableName, TColumns>,
+): StructSchemaForColumns<TColumns> =>
+  Schema.Struct(structFieldsForColumns(tableDef.columns)).annotate({
     title: tableDef.name,
-  }) as any
+  })
 
-export const insertStructSchemaForTable = <TTableDefinition extends TableDefinition<any, any>>(
-  tableDef: TTableDefinition,
-): InsertStructSchemaForColumns<TTableDefinition['columns']> =>
+export const insertStructSchemaForTable = <TTableName extends string, TColumns extends ConstraintColumns>(
+  tableDef: TableDefinition<TTableName, TColumns>,
+): InsertStructSchemaForColumns<TColumns> =>
   Schema.Struct(
     Object.fromEntries(
       tableDef.ast.columns.map((column) => [
@@ -80,7 +94,7 @@ export const insertStructSchemaForTable = <TTableDefinition extends TableDefinit
         column.nullable === true || column.default._tag === 'Some' ? Schema.optional(column.schema) : column.schema,
       ]),
     ),
-  ).annotations({
+  ).annotate({
     title: tableDef.name,
   }) as any
 
@@ -150,7 +164,7 @@ export namespace FromTable {
   }
 
   export type RowEncodeNonNullable<TTableDefinition extends TableDefinition<any, any>> = {
-    [K in keyof TTableDefinition['columns']]: Schema.Schema.Encoded<TTableDefinition['columns'][K]['schema']>
+    [K in keyof TTableDefinition['columns']]: TTableDefinition['columns'][K]['schema']['Encoded']
   }
 
   export type RowEncoded<TTableDefinition extends TableDefinition<any, any>> = Types.Simplify<
@@ -167,7 +181,7 @@ export namespace FromTable {
   // >
 
   export type RowDecodedAll<TTableDefinition extends TableDefinition<any, any>> = {
-    [K in keyof TTableDefinition['columns']]: Schema.Schema.Type<TTableDefinition['columns'][K]['schema']>
+    [K in keyof TTableDefinition['columns']]: TTableDefinition['columns'][K]['schema']['Type']
   }
 }
 
@@ -179,11 +193,11 @@ export namespace FromColumns {
   >
 
   export type RowDecodedAll<TColumns extends Columns> = {
-    readonly [K in keyof TColumns]: Schema.Schema.Type<TColumns[K]['schema']>
+    readonly [K in keyof TColumns]: TColumns[K]['schema']['Type']
   }
 
   export type RowEncodedAll<TColumns extends Columns> = {
-    readonly [K in keyof TColumns]: Schema.Schema.Encoded<TColumns[K]['schema']>
+    readonly [K in keyof TColumns]: TColumns[K]['schema']['Encoded']
   }
 
   export type RowEncoded<TColumns extends Columns> = Types.Simplify<
@@ -192,7 +206,7 @@ export namespace FromColumns {
   >
 
   export type RowEncodeNonNullable<TColumns extends Columns> = {
-    readonly [K in keyof TColumns]: Schema.Schema.Encoded<TColumns[K]['schema']>
+    readonly [K in keyof TColumns]: TColumns[K]['schema']['Encoded']
   }
 
   export type NullableColumnNames<TColumns extends Columns> = keyof {

package/src/schema/state/sqlite/db-schema/has-json-string-encoding.ts

@@ -0,0 +1,9 @@
+import { SchemaAST } from '@livestore/utils/effect'
+
+const getContentMediaType = SchemaAST.resolveAt<string>('contentMediaType')
+
+export const hasJsonStringEncoding = (ast: SchemaAST.AST): boolean => hasJsonMediaType(SchemaAST.toEncoded(ast))
+
+const hasJsonMediaType = (ast: SchemaAST.AST): boolean =>
+  getContentMediaType(ast) === 'application/json' ||
+  (SchemaAST.isUnion(ast) === true && ast.types.some(hasJsonMediaType))

package/src/schema/state/sqlite/mod.ts

@@ -4,6 +4,7 @@ import type { MigrationOptions } from '../../../adapter-types.ts'
 import type { Materializer } from '../../EventDef/mod.ts'
 import type { InternalState } from '../../schema.ts'
 import { ClientDocumentTableDefSymbol, tableIsClientDocumentTable } from './client-document-def.ts'
+import { fingerprint } from './db-schema/ast/fingerprint.ts'
 import { SqliteAst } from './db-schema/mod.ts'
 import { stateSystemTables } from './system-tables/state-tables.ts'
 import type { TableDef, TableDefBase } from './table-def.ts'
@@ -55,19 +56,17 @@ export const makeState = <TStateInput extends InputState>(inputSchema: TStateInp
     }
   }
 
-  const hash = SqliteAst.hash({
+  const hash = fingerprint({
     _tag: 'dbSchema',
     tables: [...tables.values()].map((_) => _.sqliteDef.ast),
   })
 
-  return { sqlite: { tables, migrations: inputSchema.migrations ?? { strategy: 'auto' }, hash }, materializers }
+  return { sqlite: { tables, migrations: inputSchema.migrations ?? {}, hash }, materializers }
 }
 
 export type InputState = {
   readonly tables: Record<string, TableDefBase> | ReadonlyArray<TableDefBase>
   readonly materializers: Record<string, Materializer<any>>
-  /**
-   * @default { strategy: 'auto' }
-   */
+  /** Configures hooks and logging for automatic state migration. */
   readonly migrations?: MigrationOptions
 }

package/src/schema/state/sqlite/persistence.ts

@@ -0,0 +1,11 @@
+import type { LiveStoreSchema } from '../../schema.ts'
+
+/**
+ * Returns the schema-keyed base name shared by persisted state databases.
+ *
+ * @remarks
+ *
+ * Adapters append backend-specific storage-format namespaces and file
+ * extensions.
+ */
+export const getStateDbBaseName = (schema: LiveStoreSchema): string => `state${schema.state.sqlite.hash}`

package/src/schema/state/sqlite/query-builder/api.ts

@@ -1,7 +1,7 @@
 import type { GetValForKey, SingleOrReadonlyArray } from '@livestore/utils'
 import { type Option, Predicate, type Schema } from '@livestore/utils/effect'
 
-import type { SessionIdSymbol } from '../../../../adapter-types.ts'
+import type { SessionIdSymbol } from '../../../../session-id-symbol.ts'
 import type { SqlValue } from '../../../../util.ts'
 import type { ClientDocumentTableDef, ClientDocumentTableDefSymbol } from '../client-document-def.ts'
 import type { SqliteDsl } from '../db-schema/mod.ts'
@@ -32,14 +32,14 @@ export namespace QueryBuilderAst {
     readonly limit: Option.Option<number>
     readonly tableDef: TableDefBase
     readonly where: ReadonlyArray<QueryBuilderAst.Where>
-    readonly resultSchemaSingle: Schema.Schema<any>
+    readonly resultSchemaSingle: Schema.Codec<any, any>
   }
 
   export interface CountQuery {
     readonly _tag: 'CountQuery'
     readonly tableDef: TableDefBase
     readonly where: ReadonlyArray<QueryBuilderAst.Where>
-    readonly resultSchema: Schema.Schema<number, ReadonlyArray<{ count: number }>>
+    readonly resultSchema: Schema.Codec<number, ReadonlyArray<{ count: number }>>
   }
 
   export interface RowQuery {
@@ -55,7 +55,7 @@ export namespace QueryBuilderAst {
     readonly values: Record<string, unknown>
     readonly onConflict: OnConflict | undefined
     readonly returning: string[] | undefined
-    readonly resultSchema: Schema.Schema<any>
+    readonly resultSchema: Schema.Codec<any, any>
   }
 
   export interface OnConflict {
@@ -76,7 +76,7 @@ export namespace QueryBuilderAst {
     readonly values: Record<string, unknown>
     readonly where: ReadonlyArray<QueryBuilderAst.Where>
     readonly returning: string[] | undefined
-    readonly resultSchema: Schema.Schema<any>
+    readonly resultSchema: Schema.Codec<any, any>
   }
 
   export interface DeleteQuery {
@@ -84,7 +84,7 @@ export namespace QueryBuilderAst {
     readonly tableDef: TableDefBase
     readonly where: ReadonlyArray<QueryBuilderAst.Where>
     readonly returning: string[] | undefined
-    readonly resultSchema: Schema.Schema<any>
+    readonly resultSchema: Schema.Codec<any, any>
   }
 
   export type WriteQuery = InsertQuery | UpdateQuery | DeleteQuery
@@ -115,7 +115,7 @@ export const isQueryBuilder = (value: unknown): value is QueryBuilder<any, any,
 
 export type QueryBuilder<
   TResult,
-  TTableDef extends TableDefBase,
+  TTableDef extends TableDefBase<any, any>,
   /** Used to gradually remove features from the API based on the query context */
   TWithout extends QueryBuilder.ApiFeature = never,
 > = {
@@ -230,8 +230,8 @@ export namespace QueryBuilder {
       /** Select multiple columns */
       <TColumns extends keyof TTableDef['sqliteDef']['columns'] & string>(
         ...columns: TColumns[]
-      )// params: QueryBuilderSelectParams, // TODO also support arbitrary SQL selects
-      : QueryBuilder<
+      ): QueryBuilder<
+        // params: QueryBuilderSelectParams, // TODO also support arbitrary SQL selects
         ReadonlyArray<{
           readonly [K in TColumns]: TTableDef['sqliteDef']['columns'][K]['schema']['Type']
         }>,

package/src/schema/state/sqlite/query-builder/astToSql.ts

@@ -1,48 +1,46 @@
 import { shouldNeverHappen } from '@livestore/utils'
-import { Schema, SchemaAST } from '@livestore/utils/effect'
+import { Schema, SchemaAST, Struct } from '@livestore/utils/effect'
 
-import { SessionIdSymbol } from '../../../../adapter-types.ts'
+import { SessionIdSymbol } from '../../../../session-id-symbol.ts'
 import type { SqlValue } from '../../../../util.ts'
 import type { State } from '../../../mod.ts'
+import { hasJsonStringEncoding } from '../db-schema/has-json-string-encoding.ts'
 import type { QueryBuilderAst } from './api.ts'
 
 /**
- * Extracts array element schema from a JSON array transformation AST.
- * Returns the element schema, or undefined if not a JSON array transformation.
+ * Extracts array element schema from a JSON array AST with a JSON string encoding.
+ * Returns the element schema, or undefined if the AST is not a JSON array.
  */
-const extractArrayElementFromTransformation = (ast: SchemaAST.AST): Schema.Schema.Any | undefined => {
-  if (SchemaAST.isTransformation(ast) === false) return undefined
+const extractJsonArrayElementSchema = (ast: SchemaAST.AST): Schema.Top | undefined => {
+  if (hasJsonStringEncoding(ast) === false) return undefined
 
-  const toAst = ast.to
-  // Check if the "to" side is a TupleType (Effect's internal representation of Array)
-  if (SchemaAST.isTupleType(toAst) === false) return undefined
+  const typeAst = SchemaAST.toType(ast)
+  // Check if the type side is Arrays (Effect's internal representation of Array)
+  if (SchemaAST.isArrays(typeAst) === false) return undefined
 
-  // For Schema.Array, rest contains { type: AST } elements - get the first one's type
-  const restElement = toAst.rest[0]
+  // For Schema.Array, rest contains the element AST - get the first one.
+  const restElement = typeAst.rest[0]
   if (restElement === undefined) return undefined
 
-  return Schema.make(restElement.type)
+  return Schema.make(restElement)
 }
 
 /**
- * For JSON array columns, extracts the element schema from Schema.parseJson(Schema.Array(ElementSchema)).
- * Also handles nullable JSON arrays (Schema.NullOr(Schema.parseJson(Schema.Array(...)))).
+ * For JSON array columns, extracts the element schema from Schema.fromJsonString(Schema.Array(ElementSchema)).
+ * Also handles nullable JSON arrays (Schema.NullOr(Schema.fromJsonString(Schema.Array(...)))).
  * Returns the element schema, or undefined if the column is not a JSON array.
  */
-const getJsonArrayElementSchema = (colSchema: Schema.Schema.Any): Schema.Schema.Any | undefined => {
+const getJsonArrayElementSchema = (colSchema: Schema.Top): Schema.Top | undefined => {
   const ast = colSchema.ast
 
-  // Case 1: Direct transformation (non-nullable JSON array)
-  // Schema.parseJson(Schema.Array(ElementSchema)) creates a Transformation AST
-  if (SchemaAST.isTransformation(ast) === true) {
-    return extractArrayElementFromTransformation(ast)
-  }
+  // Case 1: Direct JSON string encoding (non-nullable JSON array)
+  const direct = extractJsonArrayElementSchema(ast)
+  if (direct !== undefined) return direct
 
-  // Case 2: Nullable JSON array - Schema.NullOr wraps the parseJson in a Union
-  // Structure: Union([Transformation (JSON array), Literal (null)])
+  // Case 2: Nullable JSON array - Schema.NullOr wraps the JSON array in a Union.
   if (SchemaAST.isUnion(ast) === true) {
     for (const member of ast.types) {
-      const result = extractArrayElementFromTransformation(member)
+      const result = extractJsonArrayElementSchema(member)
       if (result !== undefined) return result
     }
   }
@@ -54,8 +52,8 @@ const getJsonArrayElementSchema = (colSchema: Schema.Schema.Any): Schema.Schema.
  * Encodes a JSON array element to the representation returned by SQLite's json_each().
  * Objects/arrays are stringified so they match json_each's TEXT representation.
  */
-const encodeJsonArrayElementValue = (elementSchema: Schema.Schema.Any, value: unknown): SqlValue => {
-  const encoded = Schema.encodeSync(elementSchema as Schema.Schema<unknown, SqlValue>)(value)
+const encodeJsonArrayElementValue = (elementSchema: Schema.Top, value: unknown): SqlValue => {
+  const encoded = Schema.encodeSync(elementSchema as Schema.Codec<unknown, SqlValue>)(value)
 
   if (encoded === null) return null
   if (typeof encoded === 'object') {
@@ -237,7 +235,7 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
       // return shouldNeverHappen('UPDATE query requires at least one column to set.')
     }
 
-    const encodedValues = Schema.encodeSync(Schema.partial(ast.tableDef.rowSchema))(ast.values)
+    const encodedValues = Schema.encodeSync(ast.tableDef.rowSchema.mapFields(Struct.map(Schema.optional)))(ast.values)
 
     // Ensure bind values are added in the same order as columns
     setColumns.forEach((col) => {