effect-qb 0.16.0 → 4.0.0-beta.66

package/src/postgres/table.ts

@@ -1,8 +1,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"
 
@@ -33,25 +32,44 @@ export type TableClassStatic<
   SchemaName extends string | undefined = "public"
 > = BaseTable.TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName>
 
-export type AnyTable = BaseTable.AnyTable
+export type AnyTable = BaseTable.AnyTable<Dialect>
 
-type FieldsOfTable<Table> = Table extends BaseTable.TableDefinition<any, infer Fields extends DialectFieldMap, any, any, any>
+type FieldsOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTable.TypeId]["fields"] extends infer Fields extends DialectFieldMap
   ? Fields
-  : Table extends BaseTable.TableClassStatic<any, infer Fields extends DialectFieldMap, any, any>
-    ? Fields
-    : never
-
-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>
-    ? PrimaryKeyColumns
-    : never
-
-type SchemaNameOfTable<Table> = Table extends BaseTable.TableDefinition<any, any, any, any, infer SchemaName>
-  ? SchemaName
-  : Table extends BaseTable.TableClassStatic<any, any, any, infer SchemaName>
-    ? SchemaName
-    : never
+  : never
+
+type ColumnNamesOfTable<Table extends BaseTable.AnyTable> = Extract<keyof FieldsOfTable<Table>, string>
+
+type PrimaryKeyOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTable.TypeId]["primaryKey"][number]
+
+type SchemaNameOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTable.TypeId]["schemaName"]
+
+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
@@ -89,6 +107,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 +171,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 +201,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 +209,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 +333,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 +364,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 +385,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 +407,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 +457,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: {
@@ -426,6 +550,10 @@ export const check: {
             })
       })()) as never
 
-export type SelectOf<Table extends { readonly schemas: { readonly select: Schema.Schema<any> } }> = BaseTable.SelectOf<Table>
-export type InsertOf<Table extends { readonly schemas: { readonly insert: Schema.Schema<any> } }> = BaseTable.InsertOf<Table>
-export type UpdateOf<Table extends { readonly schemas: { readonly update: Schema.Schema<any> } }> = BaseTable.UpdateOf<Table>
+export const selectSchema = BaseTable.selectSchema
+export const insertSchema = BaseTable.insertSchema
+export const updateSchema = BaseTable.updateSchema
+
+export type SelectOf<Table extends AnyTable> = BaseTable.SelectOf<Table>
+export type InsertOf<Table extends AnyTable> = BaseTable.InsertOf<Table>
+export type UpdateOf<Table extends AnyTable> = BaseTable.UpdateOf<Table>

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>,
+  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.Top, Db extends Expression.DbType.Any>(
+  schema: SchemaType,
+  dbType: Db
+) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
+    dbType: enrichDbType(dbType),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: undefined,
+    identity: undefined
+  })
+
+export const uuid = () => primitive(Schema.String.check(Schema.isUUID()), 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.Top>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
+    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