effect-qb 0.15.0 → 0.17.0

package/src/postgres/table.ts

@@ -3,6 +3,7 @@ import type * as Schema from "effect/Schema"
 import type * as Expression from "../internal/scalar.js"
 import { ColumnTypeId, type AnyColumnDefinition } from "../internal/column-state.js"
 import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
 
 type Dialect = "postgres"
 
@@ -41,6 +42,8 @@ type FieldsOfTable<Table> = Table extends BaseTable.TableDefinition<any, infer F
     ? Fields
     : never
 
+type ColumnNamesOfTable<Table> = Extract<keyof FieldsOfTable<Table>, string>
+
 type PrimaryKeyOfTable<Table> = Table extends BaseTable.TableDefinition<any, any, infer PrimaryKeyColumns extends string, any, any>
   ? PrimaryKeyColumns
   : Table extends BaseTable.TableClassStatic<any, any, infer PrimaryKeyColumns extends string, any>
@@ -53,6 +56,33 @@ type SchemaNameOfTable<Table> = Table extends BaseTable.TableDefinition<any, any
     ? SchemaName
     : never
 
+type ApplySchemaTableOptions<
+  Name extends string,
+  Fields extends DialectFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string,
+  SchemaName extends string,
+  Options extends BaseTable.DeclaredTableOptions
+> = BaseTable.ApplyDeclaredOptions<
+  BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
+  Options
+> extends BaseTable.TableDefinition<any, any, infer AppliedPrimaryKeyColumns extends keyof Fields & string, "schema", any>
+  ? TableDefinition<Name, Fields, AppliedPrimaryKeyColumns, "schema", SchemaName>
+  : TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
+
+export type TableSchemaNamespace<SchemaName extends string> = {
+  readonly schemaName: SchemaName
+  readonly table: <
+    Name extends string,
+    Fields extends DialectFieldMap,
+    const Options extends BaseTable.DeclaredTableOptions,
+    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
+  >(
+    name: Name,
+    fields: Fields,
+    ...options: Options & BaseTable.ValidateDeclaredOptions<BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
+  ) => ApplySchemaTableOptions<Name, Fields, PrimaryKeyColumns, SchemaName, Options>
+}
+
 export type TableOption = BaseTable.TableOption
 export type DdlExpressionLike = BaseTable.DdlExpressionLike
 export type IndexKey = BaseTable.IndexKeySpec
@@ -89,6 +119,34 @@ export const make = <
 ): TableDefinition<Name, Fields> =>
   BaseTable.make(name, fields, schemaName) as TableDefinition<Name, Fields>
 
+export const schema = <SchemaName extends string>(
+  schemaName: SchemaName
+): TableSchemaNamespace<SchemaName> => {
+  const table = <
+    Name extends string,
+    Fields extends DialectFieldMap,
+    const Options extends BaseTable.DeclaredTableOptions,
+    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
+  >(
+    name: Name,
+    fields: Fields,
+    ...declaredOptions: Options & BaseTable.ValidateDeclaredOptions<BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
+  ) =>
+    (BaseTable.schema(schemaName).table as (
+      name: Name,
+      fields: Fields,
+      ...options: BaseTable.DeclaredTableOptions
+    ) => BaseTable.TableDefinition<any, any, any, "schema", any>)(
+      name,
+      fields,
+      ...declaredOptions
+    ) as ApplySchemaTableOptions<Name, Fields, PrimaryKeyColumns, SchemaName, Options>
+  return {
+    schemaName,
+    table
+  } as unknown as TableSchemaNamespace<SchemaName>
+}
+
 export const alias = <
   Table extends AnyTable,
   AliasName extends string
@@ -125,14 +183,14 @@ export const Class = <Self = never, SchemaName extends string | undefined = "pub
 export const option = BaseTable.option
 
 type RichPrimaryKeyInput<Columns extends string | readonly string[]> = {
-  readonly columns: Columns
+  readonly columns: Columns & BaseTable.NonEmptyColumnInput<Columns>
   readonly name?: string
   readonly deferrable?: boolean
   readonly initiallyDeferred?: boolean
 }
 
 type RichUniqueInput<Columns extends string | readonly string[]> = {
-  readonly columns: Columns
+  readonly columns: Columns & BaseTable.NonEmptyColumnInput<Columns>
   readonly name?: string
   readonly nullsNotDistinct?: boolean
   readonly deferrable?: boolean
@@ -155,9 +213,7 @@ type RichIndexKeyInput =
       readonly collation?: string
     }
 
-type RichIndexInput<Columns extends string | readonly string[] = string | readonly string[]> = {
-  readonly columns?: Columns
-  readonly keys?: readonly [RichIndexKeyInput, ...RichIndexKeyInput[]]
+type RichIndexDetails = {
   readonly name?: string
   readonly unique?: boolean
   readonly method?: string
@@ -165,14 +221,98 @@ type RichIndexInput<Columns extends string | readonly string[] = string | readon
   readonly predicate?: DdlExpressionLike
 }
 
+type RichIndexInput<Columns extends string | readonly string[] = string | readonly string[]> = RichIndexDetails & (
+  | {
+      readonly columns: Columns & BaseTable.NonEmptyColumnInput<Columns>
+      readonly keys?: readonly [RichIndexKeyInput, ...RichIndexKeyInput[]]
+    }
+  | {
+      readonly columns?: Columns & BaseTable.NonEmptyColumnInput<Columns>
+      readonly keys: readonly [RichIndexKeyInput, ...RichIndexKeyInput[]]
+    }
+)
+
+type PrimaryKeyOptionSpec = Extract<TableOptionSpec, { readonly kind: "primaryKey" }>
+type UniqueOptionSpec = Extract<TableOptionSpec, { readonly kind: "unique" }>
+type IndexOptionSpec = Extract<TableOptionSpec, { readonly kind: "index" }>
+type ForeignKeyOptionSpec = Extract<TableOptionSpec, { readonly kind: "foreignKey" }>
+
+type RichPrimaryKeyOptionSpec<Columns extends string | readonly string[]> = PrimaryKeyOptionSpec & {
+  readonly kind: "primaryKey"
+  readonly columns: BaseTable.NormalizeColumns<Columns>
+}
+
+type RichUniqueOptionSpec<Columns extends string | readonly string[]> = UniqueOptionSpec & {
+  readonly kind: "unique"
+  readonly columns: BaseTable.NormalizeColumns<Columns>
+}
+
+type KnownTargetColumnsInput<
+  TargetTable extends AnyTable,
+  Columns extends string | readonly string[]
+> = BaseTable.NormalizeColumns<Columns> extends infer NormalizedColumns extends readonly string[]
+  ? string extends NormalizedColumns[number]
+    ? unknown
+    : Exclude<NormalizedColumns[number], ColumnNamesOfTable<TargetTable>> extends never
+      ? unknown
+      : never
+  : never
+
+type RichIndexColumnOption<Spec> = Spec extends { readonly columns: infer Columns extends string | readonly string[] }
+  ? { readonly columns: BaseTable.NormalizeColumns<Columns> }
+  : {}
+
+type RichIndexIncludeOption<Spec> = Spec extends { readonly include: infer Include extends readonly string[] }
+  ? { readonly include: Include }
+  : {}
+
+type RichIndexKeySpec<Key> = Key extends { readonly column: infer Column extends string }
+  ? BaseTable.IndexKeySpec & { readonly kind: "column"; readonly column: Column }
+  : BaseTable.IndexKeySpec & { readonly kind: "expression" }
+
+type RichIndexKeys<Keys extends readonly [RichIndexKeyInput, ...RichIndexKeyInput[]]> = {
+  readonly [K in keyof Keys]: Keys[K] extends RichIndexKeyInput ? RichIndexKeySpec<Keys[K]> : never
+} & readonly [BaseTable.IndexKeySpec, ...BaseTable.IndexKeySpec[]]
+
+type RichIndexKeysOption<Spec> = Spec extends { readonly keys: infer Keys extends readonly [RichIndexKeyInput, ...RichIndexKeyInput[]] }
+  ? { readonly keys: RichIndexKeys<Keys> }
+  : {}
+
+type RichIndexColumnsConstraint<Spec> = Spec extends { readonly columns: infer Columns extends string | readonly string[] }
+  ? BaseTable.NonEmptyColumnInput<Columns> extends never ? never : unknown
+  : unknown
+
+type RichIndexOptionSpec<Spec> = IndexOptionSpec & {
+  readonly kind: "index"
+  readonly name?: string
+  readonly unique?: boolean
+  readonly method?: string
+  readonly predicate?: DdlExpressionLike
+} & RichIndexColumnOption<Spec> & RichIndexIncludeOption<Spec> & RichIndexKeysOption<Spec>
+
+type RichForeignKeyOptionSpec<
+  LocalColumns extends string | readonly string[],
+  TargetTable extends AnyTable,
+  TargetColumns extends string | readonly string[]
+> = ForeignKeyOptionSpec & {
+  readonly kind: "foreignKey"
+  readonly columns: BaseTable.NormalizeColumns<LocalColumns>
+  readonly references: () => {
+    readonly tableName: string
+    readonly schemaName?: string
+    readonly columns: BaseTable.NormalizeColumns<TargetColumns>
+    readonly knownColumns: readonly ColumnNamesOfTable<TargetTable>[]
+  }
+}
+
 type RichForeignKeyInput<
   LocalColumns extends string | readonly string[],
   TargetTable extends AnyTable,
   TargetColumns extends string | readonly string[]
 > = {
-  readonly columns: LocalColumns
+  readonly columns: LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>
   readonly target: () => TargetTable
-  readonly referencedColumns: TargetColumns
+  readonly referencedColumns: TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns> & KnownTargetColumnsInput<NoInfer<TargetTable>, TargetColumns>
   readonly name?: string
   readonly onUpdate?: ReferentialAction
   readonly onDelete?: ReferentialAction
@@ -205,8 +345,13 @@ const makeTableScopedOption = <
   return builder
 }
 
-const normalizeColumns = (columns: string | readonly string[]): readonly [string, ...string[]] =>
-  (Array.isArray(columns) ? [...columns] : [columns]) as unknown as readonly [string, ...string[]]
+const normalizeColumns = (columns: string | readonly string[]): readonly [string, ...string[]] => {
+  const normalized = Array.isArray(columns) ? [...columns] : [columns]
+  if (normalized.length === 0) {
+    throw new Error("Table options require at least one column")
+  }
+  return normalized as unknown as readonly [string, ...string[]]
+}
 
 const normalizeIndexKeys = (
   keys: readonly [RichIndexKeyInput, ...RichIndexKeyInput[]]
@@ -231,14 +376,14 @@ const normalizeIndexKeys = (
 
 export const primaryKey: {
   <const Columns extends string | readonly string[]>(
-    columns: Columns
+    columns: Columns & BaseTable.NonEmptyColumnInput<Columns>
   ): BaseTable.TableOption<{
     readonly kind: "primaryKey"
     readonly columns: BaseTable.NormalizeColumns<Columns>
   }>
   <const Columns extends string | readonly string[]>(
     spec: RichPrimaryKeyInput<Columns>
-  ): BaseTable.TableOption
+  ): BaseTable.TableOption<RichPrimaryKeyOptionSpec<Columns>>
 } = ((input: unknown) =>
   isObject(input) && "columns" in input
     ? BaseTable.option({
@@ -252,14 +397,14 @@ export const primaryKey: {
 
 export const unique: {
   <const Columns extends string | readonly string[]>(
-    columns: Columns
+    columns: Columns & BaseTable.NonEmptyColumnInput<Columns>
   ): BaseTable.TableOption<{
     readonly kind: "unique"
     readonly columns: BaseTable.NormalizeColumns<Columns>
   }>
   <const Columns extends string | readonly string[]>(
     spec: RichUniqueInput<Columns>
-  ): BaseTable.TableOption
+  ): BaseTable.TableOption<RichUniqueOptionSpec<Columns>>
 } = ((input: unknown) =>
   isObject(input) && "columns" in input && ("name" in input || "nullsNotDistinct" in input || "deferrable" in input || "initiallyDeferred" in input)
     ? BaseTable.option({
@@ -274,30 +419,21 @@ export const unique: {
 
 export const index: {
   <const Columns extends string | readonly string[]>(
-    columns: Columns
+    columns: Columns & BaseTable.NonEmptyColumnInput<Columns>
   ): BaseTable.TableOption<{
     readonly kind: "index"
     readonly columns: BaseTable.NormalizeColumns<Columns>
   }>
-  <Table extends SchemaTable, const Columns extends string | readonly string[]>(
-    spec: Omit<RichIndexInput<Columns>, "predicate"> & {
+  <Table extends SchemaTable, const Columns extends string | readonly string[], const Spec extends Omit<RichIndexInput<Columns>, "predicate"> & {
       readonly predicate: TableExpressionFactory<Table>
-    }
-  ): TableScopedOptionBuilder<Table, {
-    readonly kind: "index"
-    readonly columns?: BaseTable.NormalizeColumns<Columns>
-    readonly keys?: readonly [BaseTable.IndexKeySpec, ...BaseTable.IndexKeySpec[]]
-    readonly name?: string
-    readonly unique?: boolean
-    readonly method?: string
-    readonly include?: readonly string[]
-    readonly predicate?: DdlExpressionLike
-  }>
-  <const Columns extends string | readonly string[]>(
-    spec: RichIndexInput<Columns>
-  ): BaseTable.TableOption
+  }>(
+    spec: Spec & RichIndexColumnsConstraint<Spec>
+  ): TableScopedOptionBuilder<Table, RichIndexOptionSpec<Spec>>
+  <const Columns extends string | readonly string[], const Spec extends RichIndexInput<Columns>>(
+    spec: Spec & RichIndexColumnsConstraint<Spec>
+  ): BaseTable.TableOption<RichIndexOptionSpec<Spec>>
 } = ((input: unknown) =>
-  isObject(input) && ("keys" in input || "name" in input || "unique" in input || "method" in input || "include" in input || "predicate" in input)
+  isObject(input) && ("columns" in input || "keys" in input || "name" in input || "unique" in input || "method" in input || "include" in input || "predicate" in input)
     ? (() => {
         const spec = input as RichIndexInput<string | readonly string[]> & {
           readonly predicate?: DdlExpressionLike | TableExpressionFactory<SchemaTable>
@@ -333,35 +469,35 @@ export const foreignKey = <
   TargetTable extends AnyTable,
   const TargetColumns extends string | readonly string[]
 >(
-  columnsOrSpec: LocalColumns | RichForeignKeyInput<LocalColumns, TargetTable, TargetColumns>,
+  columnsOrSpec: (LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>) | RichForeignKeyInput<LocalColumns, TargetTable, TargetColumns>,
   target?: () => TargetTable,
-  referencedColumns?: TargetColumns
-): BaseTable.TableOption =>
+  referencedColumns?: TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns> & KnownTargetColumnsInput<NoInfer<TargetTable>, TargetColumns>
+): BaseTable.TableOption<RichForeignKeyOptionSpec<LocalColumns, TargetTable, TargetColumns>> =>
   isObject(columnsOrSpec) && "columns" in columnsOrSpec && "target" in columnsOrSpec
     ? (() => {
         const spec = columnsOrSpec as RichForeignKeyInput<LocalColumns, TargetTable, TargetColumns>
-        const targetTable = spec.target() as BaseTable.AnyTable
+        const targetTable = spec.target()
         const targetState = targetTable[BaseTable.TypeId]
         return BaseTable.option({
-        kind: "foreignKey",
-        columns: normalizeColumns(spec.columns),
-        name: spec.name,
-        references: () => ({
-          tableName: targetState.baseName,
-          schemaName: targetState.schemaName,
-          columns: normalizeColumns(spec.referencedColumns),
-          knownColumns: Object.keys(targetState.fields)
-        }),
-        onUpdate: spec.onUpdate,
-        onDelete: spec.onDelete,
-        deferrable: spec.deferrable,
-        initiallyDeferred: spec.initiallyDeferred
-      })
+          kind: "foreignKey",
+          columns: normalizeColumns(spec.columns) as BaseTable.NormalizeColumns<LocalColumns>,
+          name: spec.name,
+          references: () => ({
+            tableName: targetState.baseName,
+            schemaName: targetState.schemaName,
+            columns: normalizeColumns(spec.referencedColumns) as BaseTable.NormalizeColumns<TargetColumns>,
+            knownColumns: Object.keys(targetState.fields) as unknown as readonly ColumnNamesOfTable<TargetTable>[]
+          }),
+          onUpdate: spec.onUpdate,
+          onDelete: spec.onDelete,
+          deferrable: spec.deferrable,
+          initiallyDeferred: spec.initiallyDeferred
+        } as RichForeignKeyOptionSpec<LocalColumns, TargetTable, TargetColumns>)
       })()
-    : BaseTable.foreignKey(
-        columnsOrSpec as LocalColumns,
-        target as () => BaseTable.AnyTable,
-        referencedColumns as TargetColumns
+    : BaseTable.foreignKey<LocalColumns, TargetTable, TargetColumns>(
+        columnsOrSpec as LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
+        target as () => TargetTable,
+        referencedColumns as TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns> & KnownTargetColumnsInput<NoInfer<TargetTable>, TargetColumns>
       )
 
 export const check: {

package/src/postgres/type.ts

@@ -25,6 +25,10 @@ type PostgresTypeNamespace = typeof postgresDatatypes & {
   readonly enum: <Kind extends string>(kind: Kind) => Expression.DbType.Enum<"postgres", Kind>
   readonly set: <Kind extends string>(kind: Kind) => Expression.DbType.Set<"postgres", Kind>
   readonly custom: <Kind extends string>(kind: Kind) => Expression.DbType.Base<"postgres", Kind>
+  readonly driverValueMapping: <Db extends Expression.DbType.Any>(
+    dbType: Db,
+    mapping: Expression.DriverValueMapping
+  ) => Db
 }
 
 /** Postgres database-type constructors for casts and typed column references. */

package/src/sqlite/column.ts

@@ -0,0 +1,128 @@
+import * as Schema from "effect/Schema"
+
+import * as BaseColumn from "../internal/column.js"
+import { makeColumnDefinition, type AnyColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
+import type * as Expression from "../internal/scalar.js"
+import {
+  DecimalStringSchema,
+  LocalDateStringSchema,
+  LocalDateTimeStringSchema,
+  LocalTimeStringSchema,
+  type DecimalString,
+  type LocalDateString,
+  type LocalDateTimeString,
+  type LocalTimeString
+} from "../internal/runtime/value.js"
+import { sqliteDatatypes } from "./datatypes/index.js"
+
+const enrichDbType = <Db extends Expression.DbType.Any>(dbType: Db): Db => {
+  const candidate = (sqliteDatatypes as unknown as Record<string, (() => Expression.DbType.Any) | undefined>)[dbType.kind]
+  return typeof candidate === "function"
+    ? { ...candidate(), ...dbType } as Db
+    : dbType
+}
+
+const primitive = <Type, Db extends Expression.DbType.Any>(
+  schema: Schema.Schema<Type, any, any>,
+  dbType: Db
+): ColumnDefinition<Type, Type, Type, Db, false, false, false, false, false, undefined> =>
+  makeColumnDefinition(schema as Schema.Schema<NonNullable<Type>>, {
+    dbType,
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined
+  })
+
+const renderNumericDdlType = (
+  kind: string,
+  options?: BaseColumn.NumericOptions
+): string | undefined => {
+  if (options === undefined || options.precision === undefined) {
+    return undefined
+  }
+  return options.scale === undefined
+    ? `${kind}(${options.precision})`
+    : `${kind}(${options.precision},${options.scale})`
+}
+
+export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
+  schema: SchemaType,
+  dbType: Db
+) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+    dbType: enrichDbType(dbType),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: undefined,
+    identity: undefined
+  })
+
+export const uuid = () => primitive(Schema.UUID, sqliteDatatypes.uuid())
+export const text = () => primitive(Schema.String, sqliteDatatypes.text())
+export const int = () => primitive(Schema.Int, sqliteDatatypes.int())
+export const number = (options?: BaseColumn.NumericOptions) =>
+  makeColumnDefinition(DecimalStringSchema, {
+    dbType: sqliteDatatypes.decimal(),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: renderNumericDdlType("decimal", options),
+    identity: undefined
+  })
+export const boolean = () => primitive(Schema.Boolean, sqliteDatatypes.boolean())
+export const date = () => primitive(LocalDateStringSchema, sqliteDatatypes.date())
+export const time = () => primitive(LocalTimeStringSchema, sqliteDatatypes.time())
+export const datetime = () => primitive(LocalDateTimeStringSchema, sqliteDatatypes.datetime())
+export const timestamp = () => primitive(LocalDateTimeStringSchema, sqliteDatatypes.timestamp())
+export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+    dbType: { ...sqliteDatatypes.json(), variant: "json" } as Expression.DbType.Json<"sqlite", "json">,
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: undefined,
+    identity: undefined
+  })
+
+export const nullable = BaseColumn.nullable
+export const brand = BaseColumn.brand
+export const primaryKey = BaseColumn.primaryKey
+type UniqueColumn<Column extends AnyColumnDefinition> = ReturnType<typeof BaseColumn.unique<Column>>
+
+type SqliteUniqueOptions = {
+  readonly name?: string
+  readonly nullsNotDistinct?: never
+  readonly deferrable?: never
+  readonly initiallyDeferred?: never
+}
+
+type UniqueModifier = {
+  <Column extends AnyColumnDefinition>(column: Column): UniqueColumn<Column>
+  readonly options: <const Options extends SqliteUniqueOptions>(
+    options: Options
+  ) => <Column extends AnyColumnDefinition>(column: Column) => UniqueColumn<Column>
+}
+
+export const unique = BaseColumn.unique as UniqueModifier
+const default_ = BaseColumn.default_
+export const generated = BaseColumn.generated
+export const driverValueMapping = BaseColumn.driverValueMapping
+export const references = BaseColumn.references
+export const schema = BaseColumn.schema
+export { default_ as default }
+
+export type Any = BaseColumn.Any
+export type AnyBound = BaseColumn.AnyBound

package/src/sqlite/datatypes/index.ts

@@ -0,0 +1,79 @@
+import type { DatatypeModule } from "../../internal/datatypes/define.js"
+import type * as Expression from "../../internal/scalar.js"
+import { sqliteDatatypeFamilies, sqliteDatatypeKinds } from "./spec.js"
+
+const withMetadata = <Kind extends keyof typeof sqliteDatatypeKinds & string>(
+  kind: Kind
+): Expression.DbType.Base<"sqlite", Kind> => {
+  const kindSpec = sqliteDatatypeKinds[kind]
+  const familySpec = sqliteDatatypeFamilies[kindSpec.family as keyof typeof sqliteDatatypeFamilies]
+  return {
+    dialect: "sqlite",
+    kind,
+    family: kindSpec.family,
+    runtime: kindSpec.runtime,
+    compareGroup: familySpec?.compareGroup,
+    castTargets: familySpec?.castTargets,
+    traits: familySpec?.traits
+  }
+}
+
+const sqliteDatatypeModule = {
+  custom: (kind: string) => ({
+    dialect: "sqlite",
+    kind
+  }),
+  uuid: () => ({
+    dialect: "sqlite",
+    kind: "uuid",
+    family: "uuid",
+    runtime: "string",
+    compareGroup: "uuid",
+    castTargets: ["uuid", "char", "varchar", "text"],
+    traits: {
+      textual: true
+    }
+  })
+} as Record<string, (...args: readonly any[]) => Expression.DbType.Base<"sqlite", string>>
+
+for (const kind of Object.keys(sqliteDatatypeKinds)) {
+  sqliteDatatypeModule[kind] = () => withMetadata(kind as keyof typeof sqliteDatatypeKinds & string)
+}
+
+type SqliteUuidWitness = Expression.DbType.Base<"sqlite", "uuid"> & {
+  readonly family: "uuid"
+  readonly runtime: "string"
+  readonly compareGroup: "uuid"
+  readonly castTargets: readonly ["uuid", "char", "varchar", "text"]
+  readonly traits: {
+    readonly textual: true
+  }
+}
+
+type SqliteJsonWitness = Expression.DbType.Base<"sqlite", "json"> & {
+  readonly family: "json"
+  readonly runtime: "json"
+  readonly compareGroup: "json"
+  readonly castTargets: readonly ["json", "text"]
+  readonly driverValueMapping: {
+    readonly toDriver: (value: unknown) => unknown
+  }
+}
+
+sqliteDatatypeModule.json = () => ({
+  ...withMetadata("json"),
+  driverValueMapping: {
+    toDriver: (value: unknown) => JSON.stringify(value)
+  }
+}) as SqliteJsonWitness
+
+export const sqliteDatatypes = sqliteDatatypeModule as DatatypeModule<
+  "sqlite",
+  typeof sqliteDatatypeKinds,
+  typeof sqliteDatatypeFamilies
+> & {
+  readonly uuid: () => SqliteUuidWitness
+  readonly json: () => SqliteJsonWitness
+}
+
+export type SqliteDatatypeModule = typeof sqliteDatatypes

package/src/sqlite/datatypes/spec.ts

@@ -0,0 +1,98 @@
+import type { DatatypeFamilySpec, DatatypeKindSpec } from "../../internal/datatypes/shape.js"
+
+export const sqliteDatatypeFamilies = {
+  text: {
+    compareGroup: "text",
+    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  numeric: {
+    compareGroup: "numeric",
+    castTargets: ["numeric", "integer", "real", "text", "boolean", "date", "time", "datetime"],
+    traits: {
+      ordered: true
+    }
+  },
+  integer: {
+    compareGroup: "numeric",
+    castTargets: ["integer", "numeric", "real", "text", "boolean", "date", "time", "datetime"],
+    traits: {
+      ordered: true
+    }
+  },
+  real: {
+    compareGroup: "numeric",
+    castTargets: ["real", "numeric", "integer", "text", "boolean"],
+    traits: {
+      ordered: true
+    }
+  },
+  boolean: {
+    compareGroup: "boolean",
+    castTargets: ["boolean", "integer", "numeric", "text"],
+    traits: {}
+  },
+  date: {
+    compareGroup: "date",
+    castTargets: ["date", "time", "datetime", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  time: {
+    compareGroup: "time",
+    castTargets: ["time", "date", "datetime", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  datetime: {
+    compareGroup: "datetime",
+    castTargets: ["datetime", "date", "time", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  json: {
+    compareGroup: "json",
+    castTargets: ["json", "text"],
+    traits: {}
+  },
+  blob: {
+    compareGroup: "blob",
+    castTargets: ["blob", "text"],
+    traits: {}
+  },
+  null: {
+    compareGroup: "null",
+    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
+    traits: {}
+  }
+} as const satisfies Record<string, DatatypeFamilySpec>
+
+export const sqliteDatatypeKinds = {
+  text: { family: "text", runtime: "string" },
+  varchar: { family: "text", runtime: "string" },
+  char: { family: "text", runtime: "string" },
+  clob: { family: "text", runtime: "string" },
+  int: { family: "integer", runtime: "number" },
+  integer: { family: "integer", runtime: "number" },
+  bigint: { family: "integer", runtime: "bigintString" },
+  numeric: { family: "numeric", runtime: "decimalString" },
+  decimal: { family: "numeric", runtime: "decimalString" },
+  real: { family: "real", runtime: "number" },
+  double: { family: "real", runtime: "number" },
+  boolean: { family: "boolean", runtime: "boolean" },
+  date: { family: "date", runtime: "localDate" },
+  time: { family: "time", runtime: "localTime" },
+  datetime: { family: "datetime", runtime: "localDateTime" },
+  timestamp: { family: "datetime", runtime: "localDateTime" },
+  json: { family: "json", runtime: "json" },
+  blob: { family: "blob", runtime: "bytes" }
+} as const satisfies Record<string, DatatypeKindSpec>
+
+export type SqliteDatatypeFamily = keyof typeof sqliteDatatypeFamilies
+export type SqliteDatatypeKind = keyof typeof sqliteDatatypeKinds