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

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

@@ -3,77 +3,77 @@
 exports[`FieldDefs > boolean 1`] = `
 {
   "autoIncrement": false,
-  "columnType": "text",
+  "columnType": "integer",
   "default": {
     "_id": "Option",
     "_tag": "None",
   },
   "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Boolean",
+    "decodedAst": "Boolean",
+    "encodedAst": "Union",
+  },
 }
 `;
 
 exports[`FieldDefs > boolean 2`] = `
 {
   "autoIncrement": false,
-  "columnType": "text",
+  "columnType": "integer",
   "default": {
     "_id": "Option",
     "_tag": "None",
   },
   "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Boolean",
+    "decodedAst": "Boolean",
+    "encodedAst": "Union",
+  },
 }
 `;
 
 exports[`FieldDefs > boolean 3`] = `
 {
   "autoIncrement": false,
-  "columnType": "text",
+  "columnType": "integer",
   "default": {
     "_id": "Option",
     "_tag": "Some",
-    "value": null,
+    "value": false,
   },
-  "nullable": true,
+  "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
-}
-`;
-
-exports[`FieldDefs > boolean 4`] = `
-{
-  "autoIncrement": false,
-  "columnType": "text",
-  "default": {
-    "_id": "Option",
-    "_tag": "Some",
-    "value": "foo",
+  "schema": {
+    "ast": "Boolean",
+    "decodedAst": "Boolean",
+    "encodedAst": "Union",
   },
-  "nullable": true,
-  "primaryKey": false,
-  "schema": [Function],
 }
 `;
 
-exports[`FieldDefs > boolean 5`] = `
+exports[`FieldDefs > datetime 1`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
-    "_tag": "Some",
-    "value": "foo",
+    "_tag": "None",
   },
-  "nullable": true,
+  "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Declaration",
+    "decodedAst": "Declaration",
+    "encodedAst": "String",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 6`] = `
+exports[`FieldDefs > datetime 2`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
@@ -83,11 +83,15 @@ exports[`FieldDefs > boolean 6`] = `
   },
   "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Declaration",
+    "decodedAst": "Declaration",
+    "encodedAst": "String",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 7`] = `
+exports[`FieldDefs > datetime 3`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
@@ -98,28 +102,34 @@ exports[`FieldDefs > boolean 7`] = `
   },
   "nullable": true,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Union",
+    "decodedAst": "Union",
+    "encodedAst": "Union",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 8`] = `
+exports[`FieldDefs > datetime 4`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
     "_tag": "Some",
-    "value": {
-      "name": "Bob",
-    },
+    "value": 2022-02-02T00:00:00.000Z,
   },
-  "nullable": true,
+  "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Declaration",
+    "decodedAst": "Declaration",
+    "encodedAst": "String",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 9`] = `
+exports[`FieldDefs > json 1`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
@@ -129,93 +139,143 @@ exports[`FieldDefs > boolean 9`] = `
   },
   "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Any",
+    "decodedAst": "Any",
+    "encodedAst": "String",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 10`] = `
+exports[`FieldDefs > json 2`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
-    "_tag": "None",
+    "_tag": "Some",
+    "value": null,
   },
-  "nullable": false,
+  "nullable": true,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Union",
+    "decodedAst": "Union",
+    "encodedAst": "Union",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 11`] = `
+exports[`FieldDefs > json 3`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
     "_tag": "Some",
-    "value": null,
+    "value": {
+      "name": "Bob",
+    },
   },
   "nullable": true,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Union",
+    "decodedAst": "Union",
+    "encodedAst": "Union",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 12`] = `
+exports[`FieldDefs > text 1`] = `
 {
   "autoIncrement": false,
   "columnType": "text",
   "default": {
     "_id": "Option",
-    "_tag": "Some",
-    "value": 2022-02-02T00:00:00.000Z,
+    "_tag": "None",
   },
   "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "String",
+    "decodedAst": "String",
+    "encodedAst": "String",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 13`] = `
+exports[`FieldDefs > text 2`] = `
 {
   "autoIncrement": false,
-  "columnType": "integer",
+  "columnType": "text",
   "default": {
     "_id": "Option",
     "_tag": "None",
   },
   "nullable": false,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "String",
+    "decodedAst": "String",
+    "encodedAst": "String",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 14`] = `
+exports[`FieldDefs > text 3`] = `
 {
   "autoIncrement": false,
-  "columnType": "integer",
+  "columnType": "text",
   "default": {
     "_id": "Option",
-    "_tag": "None",
+    "_tag": "Some",
+    "value": null,
   },
-  "nullable": false,
+  "nullable": true,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Union",
+    "decodedAst": "Union",
+    "encodedAst": "Union",
+  },
 }
 `;
 
-exports[`FieldDefs > boolean 15`] = `
+exports[`FieldDefs > text 4`] = `
 {
   "autoIncrement": false,
-  "columnType": "integer",
+  "columnType": "text",
   "default": {
     "_id": "Option",
     "_tag": "Some",
-    "value": false,
+    "value": "foo",
   },
-  "nullable": false,
+  "nullable": true,
   "primaryKey": false,
-  "schema": [Function],
+  "schema": {
+    "ast": "Union",
+    "decodedAst": "Union",
+    "encodedAst": "Union",
+  },
+}
+`;
+
+exports[`FieldDefs > text 5`] = `
+{
+  "autoIncrement": false,
+  "columnType": "text",
+  "default": {
+    "_id": "Option",
+    "_tag": "Some",
+    "value": "foo",
+  },
+  "nullable": true,
+  "primaryKey": false,
+  "schema": {
+    "ast": "Union",
+    "decodedAst": "Union",
+    "encodedAst": "Union",
+  },
 }
 `;

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

@@ -1,35 +1,55 @@
-import { Schema } from '@livestore/utils/effect'
 import { describe, expect, test } from 'vitest'
 
+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,12 +1,32 @@
 import { casesHandled } from '@livestore/utils'
 import { Option, Schema } from '@livestore/utils/effect'
 
-export type ColumnDefinition<TEncoded, TDecoded> = {
+import { SqliteReal } from '../../../../../util.ts'
+
+export type SqlDefaultValue = {
+  readonly sql: string
+}
+
+export const isSqlDefaultValue = (value: unknown): value is SqlDefaultValue => {
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- type guard property access after structural check
+  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) === true ? value() : value
+
+export type ColumnDefinition<TEncoded, TDecoded, TNullable extends boolean = boolean> = {
   readonly columnType: FieldColumnType
-  readonly schema: Schema.Schema<TDecoded, TEncoded>
-  readonly default: Option.Option<TEncoded>
+  readonly schema: Schema.Codec<TDecoded, TEncoded>
+  readonly default: Option.Option<ColumnDefaultValue<TDecoded>>
   /** @default false */
-  readonly nullable: boolean
+  readonly nullable: TNullable
   /** @default false */
   readonly primaryKey: boolean
   /** @default false */
@@ -23,13 +43,22 @@ export const isColumnDefinition = (value: unknown): value is ColumnDefinition.An
     typeof value === 'object' &&
     value !== null &&
     'columnType' in value &&
+    // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- type guard narrowing; columnType checked to be in valid set
     validColumnTypes.includes(value.columnType as any)
   )
 }
 
+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 schema?: Schema.Codec<unknown, unknown>
+  readonly default?: ColumnDefaultArg<unknown, boolean>
   readonly nullable?: boolean
   readonly primaryKey?: boolean
   readonly autoIncrement?: boolean
@@ -38,18 +67,10 @@ 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
-    schema: Schema.Schema<DefaultEncodedForColumnType<TColumnType>>
+    schema: Schema.Codec<DefaultEncodedForColumnType<TColumnType>>
     default: Option.None<never>
     nullable: false
     primaryKey: false
@@ -59,11 +80,11 @@ 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: {
-    schema?: Schema.Schema<TDecoded, TEncoded>
+    schema?: Schema.Codec<TDecoded, TEncoded>
     default?: TDefault
     nullable?: TNullable
     primaryKey?: TPrimaryKey
@@ -71,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>
@@ -84,10 +105,11 @@ 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)
 
+    // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- column factory return type uses complex conditional generics; consumer type safety enforced by ColDefFn signature
     return {
       columnType,
       schema,
@@ -123,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
@@ -132,13 +154,13 @@ 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,
   >(
     args: TAllowsCustomSchema extends true
       ? {
-          schema?: Schema.Schema<TDecoded, any>
+          schema?: Schema.Codec<TDecoded, any>
           default?: TDefault
           nullable?: TNullable
           primaryKey?: TPrimaryKey
@@ -153,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>
@@ -167,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>(
@@ -175,18 +197,20 @@ 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>
 }
 
 const makeSpecializedColDef: MakeSpecializedColDefFn = (columnType, opts) => (def?: ColumnDefinitionInput) => {
   const nullable = def?.nullable ?? false
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- schema type variance; custom schema compatibility checked at call site
   const schemaWithoutNull = opts._tag === 'baseSchemaFn' ? opts.baseSchemaFn(def?.schema as any) : opts.baseSchema
   const schema = nullable === true ? Schema.NullOr(schemaWithoutNull) : schemaWithoutNull
   const default_ = def?.default === undefined || def.default === NoDefault ? Option.none() : Option.some(def.default)
 
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- specialized column factory return type uses complex conditional generics; consumer type safety enforced by SpecializedColDefFn signature
   return {
     columnType,
     schema,
@@ -199,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: (_) => (_ ? 1 : 0),
-  }),
+  baseSchema: Schema.BooleanFromBit,
 })
 
 export type FieldColumnType = 'text' | 'integer' | 'real' | 'blob'
@@ -235,23 +253,25 @@ 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': {
-      return Schema.String as any as Schema.Schema<T>
+      // 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 Schema.Codec<T>
     }
     case 'integer': {
-      return Schema.Number as any as Schema.Schema<T>
+      // 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.Finite as Schema.Codec<T>
     }
     case 'real': {
-      return Schema.Number as any as Schema.Schema<T>
+      // 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 SqliteReal as Schema.Codec<T>
     }
     case 'blob': {
-      return Schema.Uint8ArrayFromSelf as any as Schema.Schema<T>
+      // 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.Uint8Array as Schema.Codec<T>
     }
     default: {
       return casesHandled(columnType)