effect-qb 0.15.0 → 0.17.0

package/src/internal/runtime/value.ts

@@ -23,50 +23,173 @@ const brandString = <BrandName extends string>(
     Schema.brand(brand)
   ) as unknown as Schema.Schema<string & Brand.Brand<BrandName>>
 
-export const LocalDateStringSchema = brandString(
-  /^\d{4}-\d{2}-\d{2}$/,
-  "LocalDateString"
-)
+export const localDatePattern = /^(\d{4})-(\d{2})-(\d{2})$/
 
-export const LocalTimeStringSchema = brandString(
-  /^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/,
-  "LocalTimeString"
-)
+export const isValidLocalDateString = (value: string): boolean => {
+  const match = localDatePattern.exec(value)
+  if (match === null) {
+    return false
+  }
+  const year = Number(match[1])
+  const month = Number(match[2])
+  const day = Number(match[3])
+  const parsed = new Date(Date.UTC(year, month - 1, day))
+  parsed.setUTCFullYear(year)
+  return parsed.getUTCFullYear() === year &&
+    parsed.getUTCMonth() === month - 1 &&
+    parsed.getUTCDate() === day
+}
 
-export const OffsetTimeStringSchema = brandString(
-  /^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/,
-  "OffsetTimeString"
-)
+export const localTimePattern = /^(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?$/
 
-export const LocalDateTimeStringSchema = brandString(
-  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?$/,
-  "LocalDateTimeString"
-)
+export const isValidLocalTimeString = (value: string): boolean => {
+  const match = localTimePattern.exec(value)
+  if (match === null) {
+    return false
+  }
+  const hour = Number(match[1])
+  const minute = Number(match[2])
+  const second = Number(match[3])
+  return hour >= 0 && hour <= 23 &&
+    minute >= 0 && minute <= 59 &&
+    second >= 0 && second <= 59
+}
 
-export const InstantStringSchema = brandString(
-  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/,
-  "InstantString"
-)
+const offsetPattern = /^(?:Z|[+-](\d{2}):(\d{2}))$/
+
+const isValidOffset = (value: string): boolean => {
+  const match = offsetPattern.exec(value)
+  if (match === null) {
+    return false
+  }
+  if (value === "Z") {
+    return true
+  }
+  const hour = Number(match[1])
+  const minute = Number(match[2])
+  return hour >= 0 && hour <= 23 &&
+    minute >= 0 && minute <= 59
+}
+
+export const offsetTimePattern = /^(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})$/
+
+export const isValidOffsetTimeString = (value: string): boolean => {
+  const match = offsetTimePattern.exec(value)
+  return match !== null &&
+    isValidLocalTimeString(match[1]!) &&
+    isValidOffset(match[2]!)
+}
+
+export const localDateTimePattern = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/
+
+export const isValidLocalDateTimeString = (value: string): boolean => {
+  const match = localDateTimePattern.exec(value)
+  return match !== null &&
+    isValidLocalDateString(match[1]!) &&
+    isValidLocalTimeString(match[2]!)
+}
+
+export const instantPattern = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})$/
+
+export const isValidInstantString = (value: string): boolean => {
+  const match = instantPattern.exec(value)
+  return match !== null &&
+    isValidLocalDateString(match[1]!) &&
+    isValidLocalTimeString(match[2]!) &&
+    isValidOffset(match[3]!)
+}
+
+export const LocalDateStringSchema = Schema.String.pipe(
+  Schema.pattern(localDatePattern),
+  Schema.filter(isValidLocalDateString),
+  Schema.brand("LocalDateString")
+) as unknown as Schema.Schema<LocalDateString>
+
+export const LocalTimeStringSchema = Schema.String.pipe(
+  Schema.pattern(localTimePattern),
+  Schema.filter(isValidLocalTimeString),
+  Schema.brand("LocalTimeString")
+) as unknown as Schema.Schema<LocalTimeString>
+
+export const OffsetTimeStringSchema = Schema.String.pipe(
+  Schema.pattern(offsetTimePattern),
+  Schema.filter(isValidOffsetTimeString),
+  Schema.brand("OffsetTimeString")
+) as unknown as Schema.Schema<OffsetTimeString>
+
+export const LocalDateTimeStringSchema = Schema.String.pipe(
+  Schema.pattern(localDateTimePattern),
+  Schema.filter(isValidLocalDateTimeString),
+  Schema.brand("LocalDateTimeString")
+) as unknown as Schema.Schema<LocalDateTimeString>
+
+export const InstantStringSchema = Schema.String.pipe(
+  Schema.pattern(instantPattern),
+  Schema.filter(isValidInstantString),
+  Schema.brand("InstantString")
+) as unknown as Schema.Schema<InstantString>
 
 export const YearStringSchema = brandString(
   /^\d{4}$/,
   "YearString"
 )
 
-export const BigIntStringSchema = brandString(
-  /^-?\d+$/,
-  "BigIntString"
-)
+export const canonicalizeBigIntString = (input: string): string => {
+  const trimmed = input.trim()
+  if (!/^-?\d+$/.test(trimmed)) {
+    throw new Error("Expected an integer-like bigint value")
+  }
+  return BigInt(trimmed).toString()
+}
 
-export const DecimalStringSchema = brandString(
-  /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/,
-  "DecimalString"
-)
+export const isCanonicalBigIntString = (value: string): boolean => {
+  try {
+    return canonicalizeBigIntString(value) === value
+  } catch {
+    return false
+  }
+}
+
+export const canonicalizeDecimalString = (input: string): string => {
+  const trimmed = input.trim()
+  const match = /^([+-]?)(\d+)(?:\.(\d+))?$/.exec(trimmed)
+  if (match === null) {
+    throw new Error("Expected a decimal string")
+  }
+  const sign = match[1] === "-" ? "-" : ""
+  const integer = match[2]!.replace(/^0+(?=\d)/, "") || "0"
+  const fraction = (match[3] ?? "").replace(/0+$/, "")
+  if (fraction.length === 0) {
+    if (integer === "0") {
+      return "0"
+    }
+    return `${sign}${integer}`
+  }
+  return `${sign}${integer}.${fraction}`
+}
+
+export const isCanonicalDecimalString = (value: string): boolean => {
+  try {
+    return canonicalizeDecimalString(value) === value
+  } catch {
+    return false
+  }
+}
+
+export const BigIntStringSchema = Schema.String.pipe(
+  Schema.filter(isCanonicalBigIntString),
+  Schema.brand("BigIntString")
+) as unknown as Schema.Schema<BigIntString>
+
+export const DecimalStringSchema = Schema.String.pipe(
+  Schema.filter(isCanonicalDecimalString),
+  Schema.brand("DecimalString")
+) as unknown as Schema.Schema<DecimalString>
 
 export const JsonValueSchema: Schema.Schema<JsonValue> = Schema.suspend(() =>
   Schema.Union(
     Schema.String,
-    Schema.Number,
+    Schema.Number.pipe(Schema.finite()),
     Schema.Boolean,
     Schema.Null,
     Schema.Array(JsonValueSchema),
@@ -79,7 +202,7 @@ export const JsonValueSchema: Schema.Schema<JsonValue> = Schema.suspend(() =>
 
 export const JsonPrimitiveSchema: Schema.Schema<JsonPrimitive> = Schema.Union(
   Schema.String,
-  Schema.Number,
+  Schema.Number.pipe(Schema.finite()),
   Schema.Boolean,
   Schema.Null
 )

package/src/internal/scalar.ts

@@ -51,6 +51,7 @@ export declare namespace DbType {
     readonly compareGroup?: string
     readonly castTargets?: readonly string[]
     readonly traits?: DatatypeTraits
+    readonly driverValueMapping?: DriverValueMapping
   }
 
   /** JSON-like database type. */
@@ -135,6 +136,15 @@ export declare namespace DbType {
     | Set<string, string>
   }
 
+export interface DriverValueMapping {
+  readonly fromDriver?: (value: unknown, dbType: DbType.Any) => unknown
+  readonly toDriver?: (value: unknown, dbType: DbType.Any) => unknown
+  readonly selectSql?: (sql: string, dbType: DbType.Any) => string
+  readonly jsonSelectSql?: (sql: string, dbType: DbType.Any) => string
+}
+
+export type DriverValueMappings = Readonly<Record<string, DriverValueMapping | undefined>>
+
 /** Canonical static metadata stored on an expression. */
 export interface State<
   Runtime,
@@ -147,6 +157,7 @@ export interface State<
   readonly runtime: Runtime
   readonly dbType: Db
   readonly runtimeSchema?: Schema.Schema.Any
+  readonly driverValueMapping?: DriverValueMapping
   readonly nullability: Nullable
   readonly dialect: Dialect
   readonly kind: Kind

package/src/internal/table-options.ts

@@ -15,6 +15,30 @@ export type DdlExpressionLike = AnyExpression | AnySchemaExpression
 
 export type ReferentialAction = "noAction" | "restrict" | "cascade" | "setNull" | "setDefault"
 
+const referentialActionError = "Foreign key action must be noAction, restrict, cascade, setNull, or setDefault"
+
+export const renderReferentialAction = (action: unknown): string => {
+  switch (action) {
+    case "noAction":
+      return "no action"
+    case "restrict":
+      return "restrict"
+    case "cascade":
+      return "cascade"
+    case "setNull":
+      return "set null"
+    case "setDefault":
+      return "set default"
+  }
+  throw new Error(referentialActionError)
+}
+
+const validateReferentialAction = (action: unknown): void => {
+  if (action !== undefined) {
+    renderReferentialAction(action)
+  }
+}
+
 export type IndexKeySpec =
   | {
       readonly kind: "column"
@@ -107,6 +131,18 @@ type TupleFromColumns<Columns> = Columns extends readonly [infer Head extends st
       ? readonly [Columns]
       : never
 
+export type NonEmptyColumnInput<Columns extends string | readonly string[]> =
+  TupleFromColumns<Columns> extends never ? never : Columns
+
+export type MatchingColumnArityInput<
+  Left extends string | readonly string[],
+  Right extends string | readonly string[]
+> = TupleFromColumns<Left>["length"] extends TupleFromColumns<Right>["length"]
+  ? TupleFromColumns<Right>["length"] extends TupleFromColumns<Left>["length"]
+    ? unknown
+    : never
+  : never
+
 type AssertKnownColumns<Fields extends TableFieldMap, Columns extends readonly string[]> = Exclude<
   Columns[number],
   ColumnNameUnion<Fields>
@@ -114,6 +150,47 @@ type AssertKnownColumns<Fields extends TableFieldMap, Columns extends readonly s
   ? Columns
   : never
 
+type IndexKeyColumnNames<Keys> = Keys extends readonly (infer Key)[]
+  ? Key extends { readonly kind: "column"; readonly column: infer Column extends string }
+    ? Column
+    : never
+  : never
+
+type IndexOptionColumnNames<Spec> =
+  | (Spec extends { readonly columns: infer Columns extends readonly string[] } ? Columns[number] : never)
+  | (Spec extends { readonly include: infer Include extends readonly string[] } ? Include[number] : never)
+  | (Spec extends { readonly keys: infer Keys } ? IndexKeyColumnNames<Keys> : never)
+
+type ForeignKeyReferencedColumnNames<Spec> = Spec extends { readonly references: () => infer Reference }
+  ? Reference extends { readonly columns: infer Columns extends readonly string[] }
+    ? Columns[number]
+    : never
+  : never
+
+type ForeignKeyKnownReferencedColumnNames<Spec> = Spec extends { readonly references: () => infer Reference }
+  ? Reference extends { readonly knownColumns: infer KnownColumns extends readonly string[] }
+    ? KnownColumns[number]
+    : string
+  : string
+
+type AssertKnownColumnNames<Fields extends TableFieldMap, Columns extends string> = [Columns] extends [never]
+  ? true
+  : string extends Columns
+    ? true
+    : Exclude<Columns, ColumnNameUnion<Fields>> extends never
+      ? true
+      : false
+
+type AssertKnownReferenceColumnNames<KnownColumns extends string, Columns extends string> = [Columns] extends [never]
+  ? true
+  : string extends Columns
+    ? true
+    : string extends KnownColumns
+      ? true
+      : Exclude<Columns, KnownColumns> extends never
+        ? true
+        : false
+
 type AssertPrimaryKeyColumns<
   Fields extends TableFieldMap,
   Columns extends readonly string[]
@@ -159,6 +236,8 @@ export const collectInlineOptions = <Fields extends TableFieldMap>(
       })
     }
     if (column.metadata.references) {
+      validateReferentialAction(column.metadata.references.onUpdate)
+      validateReferentialAction(column.metadata.references.onDelete)
       const local = [columnName] as ColumnList
       options.push({
         kind: "foreignKey",
@@ -254,6 +333,8 @@ export const validateOptions = <Fields extends TableFieldMap>(
           }
         }
         if (option.kind === "foreignKey") {
+          validateReferentialAction(option.onUpdate)
+          validateReferentialAction(option.onDelete)
           const reference = option.references()
           if (reference.columns.length !== columns.length) {
             throw new Error(`Foreign key on table '${tableName}' must reference the same number of columns`)
@@ -278,7 +359,7 @@ export const validateOptions = <Fields extends TableFieldMap>(
               throw new Error(`Unknown index key column '${key.column}' on table '${tableName}'`)
             }
           }
-          if (option.columns === undefined && (option.keys === undefined || option.keys.length === 0)) {
+          if (columns.length === 0 && (option.keys === undefined || option.keys.length === 0)) {
             throw new Error(`Index on table '${tableName}' requires at least one column or key`)
           }
         }
@@ -308,5 +389,31 @@ export type ValidatePrimaryKeyColumns<
   Columns extends readonly string[]
 > = AssertPrimaryKeyColumns<Fields, AssertKnownColumns<Fields, Columns>>
 
+/** Compile-time validation that index columns, included columns, and column keys exist on the table. */
+export type ValidateIndexOptionColumns<
+  Fields extends TableFieldMap,
+  Spec
+> = AssertKnownColumnNames<Fields, IndexOptionColumnNames<Spec>> extends true ? Spec : never
+
+/** Compile-time validation that foreign keys reference known local and target columns. */
+export type ValidateForeignKeyOptionColumns<
+  Fields extends TableFieldMap,
+  Spec
+> = Spec extends { readonly columns: infer Columns extends readonly string[] }
+  ? AssertKnownColumns<Fields, Columns> extends never
+    ? never
+    : AssertKnownReferenceColumnNames<
+        ForeignKeyKnownReferencedColumnNames<Spec>,
+        ForeignKeyReferencedColumnNames<Spec>
+      > extends true
+      ? Spec
+      : never
+  : AssertKnownReferenceColumnNames<
+      ForeignKeyKnownReferencedColumnNames<Spec>,
+      ForeignKeyReferencedColumnNames<Spec>
+    > extends true
+    ? Spec
+    : never
+
 /** Normalizes a public column input into the internal tuple form. */
 export type NormalizeColumns<Columns extends string | readonly string[]> = TupleFromColumns<Columns>

package/src/internal/table.ts

@@ -12,9 +12,13 @@ import {
   resolvePrimaryKeyColumns,
   type DdlExpressionLike,
   type IndexKeySpec,
+  type MatchingColumnArityInput,
+  type NonEmptyColumnInput,
   type NormalizeColumns,
   type ReferentialAction,
   type TableOptionSpec,
+  type ValidateForeignKeyOptionColumns,
+  type ValidateIndexOptionColumns,
   type ValidateKnownColumns,
   type ValidatePrimaryKeyColumns,
   validateOptions
@@ -44,18 +48,32 @@ type InlinePrimaryKeyKeys<Fields extends TableFieldMap> = Extract<{
 type TableDialect<Fields extends TableFieldMap> = Fields[keyof Fields][typeof import("./column-state.js").ColumnTypeId]["dbType"]["dialect"]
 type TableKind = "schema" | "alias"
 type DefaultSchemaName = "public"
-type ClassOptionSpec = Exclude<TableOptionSpec, { readonly kind: "primaryKey" }>
+type FieldColumnName<Fields extends TableFieldMap> = Extract<keyof Fields, string>
+type FieldColumnList<Fields extends TableFieldMap> = readonly [FieldColumnName<Fields>, ...FieldColumnName<Fields>[]]
+type FieldIndexKeySpec<Fields extends TableFieldMap> =
+  | (Extract<IndexKeySpec, { readonly kind: "column" }> & { readonly column: FieldColumnName<Fields> })
+  | Extract<IndexKeySpec, { readonly kind: "expression" }>
+type ClassOptionSpec<Fields extends TableFieldMap = TableFieldMap> =
+  | (Omit<Extract<TableOptionSpec, { readonly kind: "index" }>, "columns" | "include" | "keys"> & {
+      readonly columns?: FieldColumnList<Fields>
+      readonly include?: readonly FieldColumnName<Fields>[]
+      readonly keys?: readonly [FieldIndexKeySpec<Fields>, ...FieldIndexKeySpec<Fields>[]]
+    })
+  | (Omit<Extract<TableOptionSpec, { readonly kind: "unique" }>, "columns"> & {
+      readonly columns: FieldColumnList<Fields>
+    })
+  | (Omit<Extract<TableOptionSpec, { readonly kind: "foreignKey" }>, "columns"> & {
+      readonly columns: FieldColumnList<Fields>
+    })
+  | Extract<TableOptionSpec, { readonly kind: "check" }>
 interface TableOptionBuilderLike<
   Spec extends TableOptionSpec = TableOptionSpec
 > {
-  (
-    table: TableDefinition<any, any, any, "schema", any>
-  ): TableDefinition<any, any, any, "schema", any>
   readonly option: Spec
 }
 
-type ClassTableOption = TableOptionBuilderLike<ClassOptionSpec>
-type ClassDeclaredTableOptions = readonly ClassTableOption[]
+type ClassTableOption<Fields extends TableFieldMap> = TableOptionBuilderLike<ClassOptionSpec<Fields>>
+type ClassDeclaredTableOptions<Fields extends TableFieldMap> = readonly ClassTableOption<Fields>[]
 
 type BuildPrimaryKey<
   Table extends TableDefinition<any, any, any, "schema", any>,
@@ -69,9 +87,13 @@ type OptionInputTable<
   Spec extends TableOptionSpec
 > = Spec extends { readonly kind: "primaryKey"; readonly columns: infer Columns extends readonly string[] }
   ? ValidatePrimaryKeyColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : Table
-  : Spec extends { readonly columns: infer Columns extends readonly string[] }
-    ? ValidateKnownColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : Table
-    : Table
+  : Spec extends { readonly kind: "index" }
+    ? ValidateIndexOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : Table
+    : Spec extends { readonly kind: "foreignKey" }
+      ? ValidateForeignKeyOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : Table
+      : Spec extends { readonly columns: infer Columns extends readonly string[] }
+        ? ValidateKnownColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : Table
+        : Table
 
 type ApplyOption<
   Table extends TableDefinition<any, any, any, "schema", any>,
@@ -90,6 +112,26 @@ type ApplyOption<
     "schema"
   >
 
+export type ValidateDeclaredOptions<
+  Table extends TableDefinition<any, any, any, "schema", any>,
+  Options extends DeclaredTableOptions
+> = {
+  readonly [K in keyof Options]: Options[K] extends TableOptionBuilderLike<infer Spec>
+    ? OptionInputTable<Table, Spec> extends never ? never : Options[K]
+    : never
+}
+
+export type ApplyDeclaredOptions<
+  Table extends TableDefinition<any, any, any, "schema", any>,
+  Options extends DeclaredTableOptions
+> = Options extends readonly [infer Head, ...infer Tail]
+  ? Head extends TableOptionBuilderLike<infer Spec>
+    ? Tail extends DeclaredTableOptions
+      ? ApplyDeclaredOptions<ApplyOption<Table, Spec>, Tail>
+      : ApplyOption<Table, Spec>
+    : Table
+  : Table
+
 export type MissingSelfGeneric = "Missing `Self` generic - use `class Self extends Table.Class<Self>(...) {}`"
 
 /** Bound columns keyed by field name for a particular table. */
@@ -132,16 +174,17 @@ export interface TableSchemaNamespace<SchemaName extends string> {
   readonly table: <
     Name extends string,
     Fields extends TableFieldMap,
+    const Options extends DeclaredTableOptions,
     PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
   >(
     name: Name,
     fields: Fields,
-    ...options: DeclaredTableOptions
-  ) => TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
+    ...options: Options & ValidateDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
+  ) => ApplyDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
 }
 
 export type DeclaredTableOptions = readonly TableOptionBuilderLike[]
-export type { DdlExpressionLike, IndexKeySpec, NormalizeColumns, ReferentialAction } from "./table-options.js"
+export type { DdlExpressionLike, IndexKeySpec, MatchingColumnArityInput, NonEmptyColumnInput, NormalizeColumns, ReferentialAction } from "./table-options.js"
 
 export type TableDefinition<
   Name extends string,
@@ -192,7 +235,7 @@ export type TableClassStatic<
   >
   readonly [OptionsSymbol]: readonly TableOptionSpec[]
   readonly [DeclaredOptionsSymbol]?: readonly TableOptionSpec[]
-  readonly [options]?: ClassDeclaredTableOptions
+  readonly [options]?: ClassDeclaredTableOptions<Fields>
   readonly tableName: Name
 } & BoundColumns<Name, Fields> & Plan.RowSet<
     BoundColumns<Name, Fields>,
@@ -204,6 +247,14 @@ export type TableClassStatic<
 /** Minimal structural table-like contract used across helper APIs. */
 export type AnyTable = TableDefinition<any, any, any, any, any> | TableClassStatic<any, any, any, any>
 
+type FieldsOfAnyTable<Table extends AnyTable> = Table extends TableDefinition<any, infer Fields extends TableFieldMap, any, any, any>
+  ? Fields
+  : Table extends TableClassStatic<any, infer Fields extends TableFieldMap, any, any>
+    ? Fields
+    : never
+
+type ColumnNamesOfAnyTable<Table extends AnyTable> = Extract<keyof FieldsOfAnyTable<Table>, string>
+
 /** Public table-option builder type used by `Table.index`, `Table.primaryKey`, and friends. */
 export type TableOption<
   Spec extends TableOptionSpec = TableOptionSpec
@@ -341,7 +392,10 @@ const applyDeclaredOptions = <
     return table
   }
   return declaredOptions.reduce<TableDefinition<any, any, any, "schema", any>>(
-    (current, option) => option(current),
+    (current, option) =>
+      (option as unknown as (
+        table: TableDefinition<any, any, any, "schema", any>
+      ) => TableDefinition<any, any, any, "schema", any>)(current),
     table
   ) as unknown as Table
 }
@@ -491,17 +545,17 @@ export function make<
  */
 export const schema = <SchemaName extends string>(
   schemaName: SchemaName
-): TableSchemaNamespace<SchemaName> => ({
-  schemaName,
-  table: <
+): TableSchemaNamespace<SchemaName> => {
+  const table = <
     Name extends string,
     Fields extends TableFieldMap,
+    const Options extends DeclaredTableOptions,
     PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
   >(
     name: Name,
     fields: Fields,
-    ...options: DeclaredTableOptions
-  ): TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName> =>
+    ...options: Options & ValidateDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
+  ): ApplyDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options> =>
     applyDeclaredOptions(
       makeTable(
         name,
@@ -512,9 +566,13 @@ export const schema = <SchemaName extends string>(
         schemaName,
         "explicit"
       ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
-      options
-    )
-})
+      options as unknown as Options
+    ) as ApplyDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
+  return {
+    schemaName,
+    table
+  } as unknown as TableSchemaNamespace<SchemaName>
+}
 
 /**
  * Creates an aliased source from an existing table definition.
@@ -664,7 +722,7 @@ export function Class<
 export const primaryKey = <
   const Columns extends string | readonly string[]
 >(
-  columns: Columns
+  columns: Columns & NonEmptyColumnInput<Columns>
 ): TableOption<{
   readonly kind: "primaryKey"
   readonly columns: NormalizeColumns<Columns>
@@ -677,7 +735,7 @@ export const primaryKey = <
 export const unique = <
   const Columns extends string | readonly string[]
 >(
-  columns: Columns
+  columns: Columns & NonEmptyColumnInput<Columns>
 ): TableOption<{
   readonly kind: "unique"
   readonly columns: NormalizeColumns<Columns>
@@ -690,7 +748,7 @@ export const unique = <
 export const index = <
   const Columns extends string | readonly string[]
 >(
-  columns: Columns
+  columns: Columns & NonEmptyColumnInput<Columns>
 ): TableOption<{
   readonly kind: "index"
   readonly columns: NormalizeColumns<Columns>
@@ -705,9 +763,9 @@ export const foreignKey = <
   TargetTable extends AnyTable,
   const TargetColumns extends string | readonly string[]
 >(
-  columns: LocalColumns,
+  columns: LocalColumns & NonEmptyColumnInput<LocalColumns>,
   target: () => TargetTable,
-  referencedColumns: TargetColumns
+  referencedColumns: TargetColumns & NonEmptyColumnInput<TargetColumns> & MatchingColumnArityInput<LocalColumns, TargetColumns>
 ): TableOption<{
   readonly kind: "foreignKey"
   readonly columns: NormalizeColumns<LocalColumns>
@@ -715,7 +773,7 @@ export const foreignKey = <
     readonly tableName: string
     readonly schemaName?: string
     readonly columns: NormalizeColumns<TargetColumns>
-    readonly knownColumns: readonly string[]
+    readonly knownColumns: readonly ColumnNamesOfAnyTable<TargetTable>[]
   }
 }> => makeOption({
   kind: "foreignKey",
@@ -724,7 +782,7 @@ export const foreignKey = <
     tableName: target()[TypeId].baseName,
     schemaName: target()[TypeId].schemaName,
     columns: normalizeColumnList(referencedColumns) as NormalizeColumns<TargetColumns>,
-    knownColumns: Object.keys(target()[TypeId].fields)
+    knownColumns: Object.keys(target()[TypeId].fields) as unknown as readonly ColumnNamesOfAnyTable<TargetTable>[]
   })
 })
 

package/src/mysql/column.ts

@@ -1,7 +1,7 @@
 import * as Schema from "effect/Schema"
 
 import * as BaseColumn from "../internal/column.js"
-import { makeColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
+import { makeColumnDefinition, type AnyColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
 import type * as Expression from "../internal/scalar.js"
 import {
   DecimalStringSchema,
@@ -97,9 +97,26 @@ export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =
 export const nullable = BaseColumn.nullable
 export const brand = BaseColumn.brand
 export const primaryKey = BaseColumn.primaryKey
-export const unique = BaseColumn.unique
+type UniqueColumn<Column extends AnyColumnDefinition> = ReturnType<typeof BaseColumn.unique<Column>>
+
+type MysqlUniqueOptions = {
+  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 MysqlUniqueOptions>(
+    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 }