effect-qb 0.16.0 → 4.0.0-beta.66

package/src/internal/table.ts

@@ -12,18 +12,25 @@ 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
 } from "./table-options.js"
 import {
-  deriveSchemas,
+  deriveInsertSchema,
+  deriveSelectSchema,
+  deriveUpdateSchema,
   type InsertRow,
   type SelectRow,
   type TableFieldMap,
+  type TableSchemaVariant,
   type UpdateRow
 } from "./schema-derivation.js"
 
@@ -35,6 +42,7 @@ export const OptionsSymbol: unique symbol = Symbol.for("effect-qb/Table/normaliz
 export const options: unique symbol = Symbol.for("effect-qb/Table/declaredOptions")
 
 const CacheSymbol: unique symbol = Symbol.for("effect-qb/Table/cache")
+const SchemaCacheSymbol: unique symbol = Symbol.for("effect-qb/Table/schemaCache")
 const DeclaredOptionsSymbol: unique symbol = Symbol.for("effect-qb/Table/factoryDeclaredOptions")
 
 type InlinePrimaryKeyKeys<Fields extends TableFieldMap> = Extract<{
@@ -44,18 +52,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 +91,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 +116,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. */
@@ -106,9 +152,17 @@ export interface TableSchemas<
   Fields extends TableFieldMap,
   PrimaryKeyColumns extends keyof Fields & string
 > {
-  readonly select: Schema.Schema<SelectRow<Name, Fields>>
-  readonly insert: Schema.Schema<InsertRow<Name, Fields>>
-  readonly update: Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>
+  readonly select: Schema.Decoder<SelectRow<Name, Fields>, never>
+  readonly insert: Schema.Decoder<InsertRow<Name, Fields>, never>
+  readonly update: Schema.Decoder<UpdateRow<Name, Fields, PrimaryKeyColumns>, never>
+}
+
+type TableSchemaCache<
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+> = Partial<TableSchemas<Name, Fields, PrimaryKeyColumns>> & {
+  schemas?: TableSchemas<Name, Fields, PrimaryKeyColumns>
 }
 
 interface TableState<
@@ -132,16 +186,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 +247,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>,
@@ -202,7 +257,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>
+export type AnyTable<Dialect extends string = string> = {
+  readonly [TypeId]: TableState<string, TableFieldMap, string, TableKind, string | undefined>
+  readonly [OptionsSymbol]: readonly TableOptionSpec[]
+} & Plan.RowSet<any, any, Record<string, Plan.AnySource>, Dialect>
+
+type FieldsOfAnyTable<Table extends AnyTable> = Table[typeof TypeId]["fields"]
+
+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<
@@ -241,7 +303,6 @@ type BuildArtifacts<
   PrimaryKeyColumns extends keyof Fields & string
 > = {
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
   readonly normalizedOptions: readonly TableOptionSpec[]
   readonly primaryKey: readonly PrimaryKeyColumns[]
 }
@@ -263,15 +324,149 @@ const buildArtifacts = <
   const columns = Object.fromEntries(
     Object.entries(fields).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName)])
   ) as BoundColumns<Name, Fields>
-  const schemas = deriveSchemas(name, fields, primaryKey)
   return {
     columns,
-    schemas,
     normalizedOptions,
     primaryKey
   }
 }
 
+const getSchemaCache = <
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>
+): TableSchemaCache<Name, Fields, PrimaryKeyColumns> => {
+  const target = table as unknown as {
+    [SchemaCacheSymbol]?: TableSchemaCache<Name, Fields, PrimaryKeyColumns>
+  }
+  if (target[SchemaCacheSymbol] !== undefined) {
+    return target[SchemaCacheSymbol]
+  }
+  const cache: TableSchemaCache<Name, Fields, PrimaryKeyColumns> = {}
+  Object.defineProperty(table, SchemaCacheSymbol, {
+    configurable: true,
+    value: cache
+  })
+  return cache
+}
+
+const deriveTableSchema = <
+  Variant extends TableSchemaVariant,
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>,
+  variant: Variant
+): TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant] => {
+  const state = table[TypeId]
+  switch (variant) {
+    case "select":
+      return deriveSelectSchema(state.name, state.fields, state.primaryKey) as TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant]
+    case "insert":
+      return deriveInsertSchema(state.name, state.fields, state.primaryKey) as TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant]
+    case "update":
+      return deriveUpdateSchema(state.name, state.fields, state.primaryKey) as TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant]
+  }
+}
+
+const schemaFor = <
+  Variant extends TableSchemaVariant,
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>,
+  variant: Variant
+): TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant] => {
+  const cache = getSchemaCache(table)
+  const cached = cache[variant]
+  if (cached !== undefined) {
+    return cached as TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant]
+  }
+  const schema = deriveTableSchema(table, variant)
+  cache[variant] = schema as any
+  return schema
+}
+
+export function selectSchema<
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>
+): Schema.Decoder<SelectRow<Name, Fields>, never> {
+  return schemaFor(table, "select") as Schema.Decoder<SelectRow<Name, Fields>, never>
+}
+
+export function insertSchema<
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>
+): Schema.Decoder<InsertRow<Name, Fields>, never> {
+  return schemaFor(table, "insert") as Schema.Decoder<InsertRow<Name, Fields>, never>
+}
+
+export function updateSchema<
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>
+): Schema.Decoder<UpdateRow<Name, Fields, PrimaryKeyColumns>, never> {
+  return schemaFor(table, "update") as Schema.Decoder<UpdateRow<Name, Fields, PrimaryKeyColumns>, never>
+}
+
+const schemasFor = <
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>
+): TableSchemas<Name, Fields, PrimaryKeyColumns> => {
+  const cache = getSchemaCache(table)
+  if (cache.schemas !== undefined) {
+    return cache.schemas
+  }
+  const schemas = {} as TableSchemas<Name, Fields, PrimaryKeyColumns>
+  Object.defineProperties(schemas, {
+    select: {
+      enumerable: true,
+      get: () => selectSchema(table)
+    },
+    insert: {
+      enumerable: true,
+      get: () => insertSchema(table)
+    },
+    update: {
+      enumerable: true,
+      get: () => updateSchema(table)
+    }
+  })
+  cache.schemas = schemas
+  return schemas
+}
+
+const defineSchemasGetter = <
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any>
+): void => {
+  Object.defineProperty(table, "schemas", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return schemasFor(table)
+    }
+  })
+}
+
 const makeTable = <
   Name extends string,
   Fields extends TableFieldMap,
@@ -295,7 +490,7 @@ const makeTable = <
   const table = attachPipe(Object.create(TableProto))
   table.name = name
   table.columns = artifacts.columns
-  table.schemas = artifacts.schemas
+  defineSchemasGetter(table)
   table[TypeId] = {
     name,
     baseName,
@@ -341,7 +536,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
 }
@@ -403,7 +601,6 @@ const ensureClassArtifacts = <
   )
   const artifacts = {
     columns: table.columns,
-    schemas: table.schemas,
     normalizedOptions: table[OptionsSymbol],
     primaryKey: table[TypeId].primaryKey as readonly PrimaryKeyColumns[]
   } satisfies BuildArtifacts<Name, Fields, PrimaryKeyColumns>
@@ -491,17 +688,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 +709,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.
@@ -546,7 +747,7 @@ export const alias = <
   const aliased = attachPipe(Object.create(TableProto))
   aliased.name = aliasName
   aliased.columns = columns
-  aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey)
+  defineSchemasGetter(aliased)
   aliased[TypeId] = {
     name: aliasName,
     baseName: state.baseName,
@@ -605,7 +806,7 @@ export function Class<
         }
 
         static get schemas() {
-          return ensureClassArtifacts(this as any).schemas
+          return schemasFor(this as any)
         }
 
         static get [TypeId]() {
@@ -664,7 +865,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 +878,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 +891,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 +906,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 +916,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 +925,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>[]
   })
 })
 
@@ -742,15 +943,21 @@ export const check = <Name extends string>(
   predicate
 })
 
-/** Extracts the row type of a table's select schema. */
-export type SelectOf<Table extends { readonly schemas: { readonly select: Schema.Schema<any> } }> = Schema.Schema.Type<
-  Table["schemas"]["select"]
->
-/** Extracts the payload type of a table's insert schema. */
-export type InsertOf<Table extends { readonly schemas: { readonly insert: Schema.Schema<any> } }> = Schema.Schema.Type<
-  Table["schemas"]["insert"]
->
-/** Extracts the payload type of a table's update schema. */
-export type UpdateOf<Table extends { readonly schemas: { readonly update: Schema.Schema<any> } }> = Schema.Schema.Type<
-  Table["schemas"]["update"]
->
+/** Extracts the row type produced by `selectSchema(table)`. */
+export type SelectOf<Table extends AnyTable> = Table[typeof TypeId] extends {
+  readonly name: infer Name extends string
+  readonly fields: infer Fields extends TableFieldMap
+} ? SelectRow<Name, Fields> : never
+
+/** Extracts the payload type produced by `insertSchema(table)`. */
+export type InsertOf<Table extends AnyTable> = Table[typeof TypeId] extends {
+  readonly name: infer Name extends string
+  readonly fields: infer Fields extends TableFieldMap
+} ? InsertRow<Name, Fields> : never
+
+/** Extracts the payload type produced by `updateSchema(table)`. */
+export type UpdateOf<Table extends AnyTable> = Table[typeof TypeId] extends {
+  readonly name: infer Name extends string
+  readonly fields: infer Fields extends TableFieldMap
+  readonly primaryKey: readonly (infer PrimaryKeyColumns)[]
+} ? UpdateRow<Name, Fields, Extract<PrimaryKeyColumns, keyof Fields & string>> : never

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,
@@ -21,7 +21,7 @@ const enrichDbType = <Db extends Expression.DbType.Any>(dbType: Db): Db => {
 }
 
 const primitive = <Type, Db extends Expression.DbType.Any>(
-  schema: Schema.Schema<Type, any, 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>>, {
@@ -46,11 +46,11 @@ const renderNumericDdlType = (
     : `${kind}(${options.precision},${options.scale})`
 }
 
-export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
+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>>, any, any>, {
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: enrichDbType(dbType),
     nullable: false,
     hasDefault: false,
@@ -62,7 +62,7 @@ export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expressi
     identity: undefined
   })
 
-export const uuid = () => primitive(Schema.UUID, mysqlDatatypes.uuid())
+export const uuid = () => primitive(Schema.String.check(Schema.isUUID()), mysqlDatatypes.uuid())
 export const text = () => primitive(Schema.String, mysqlDatatypes.text())
 export const int = () => primitive(Schema.Int, mysqlDatatypes.int())
 export const number = (options?: BaseColumn.NumericOptions) =>
@@ -81,8 +81,8 @@ export const boolean = () => primitive(Schema.Boolean, mysqlDatatypes.boolean())
 export const date = () => primitive(LocalDateStringSchema, mysqlDatatypes.date())
 export const datetime = () => primitive(LocalDateTimeStringSchema, mysqlDatatypes.datetime())
 export const timestamp = () => primitive(LocalDateTimeStringSchema, mysqlDatatypes.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>, {
+export const json = <SchemaType extends Schema.Top>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: { ...mysqlDatatypes.json(), variant: "json" } as Expression.DbType.Json<"mysql", "json">,
     nullable: false,
     hasDefault: false,
@@ -97,7 +97,23 @@ 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

package/src/mysql/datatypes/index.ts

@@ -50,12 +50,33 @@ type MysqlUuidWitness = Expression.DbType.Base<"mysql", "uuid"> & {
   }
 }
 
+type MysqlJsonWitness = Expression.DbType.Base<"mysql", "json"> & {
+  readonly family: "json"
+  readonly runtime: "json"
+  readonly compareGroup: "json"
+  readonly castTargets: readonly ["json", "text"]
+  readonly driverValueMapping: {
+    readonly toDriver: (value: unknown) => unknown
+  }
+}
+
+mysqlDatatypeModule.json = () => ({
+  ...withMetadata("json"),
+  driverValueMapping: {
+    toDriver: (value: unknown) =>
+      value !== null && typeof value === "object"
+        ? JSON.stringify(value)
+        : value
+  }
+}) as MysqlJsonWitness
+
 export const mysqlDatatypes = mysqlDatatypeModule as DatatypeModule<
   "mysql",
   typeof mysqlDatatypeKinds,
   typeof mysqlDatatypeFamilies
 > & {
   readonly uuid: () => MysqlUuidWitness
+  readonly json: () => MysqlJsonWitness
 }
 
 export type MysqlDatatypeModule = typeof mysqlDatatypes

package/src/mysql/errors/catalog.ts

@@ -51636,17 +51636,17 @@ export const mysqlErrorCatalogByNumber = {
   "MY-015153": [mysqlErrorCatalogBySymbol["ER_WARN_AUDIT_LOG_FILTER_RECOVERY_LOGGING_DISABLED_LOG"]!],
 } as const
 
-const mysqlSymbolPattern = /^(?:[A-Z][A-Z0-9_]*|MY-\d+)$/
-const mysqlNumberPattern = /^(?:\d+|MY-\d+)$/
-
 export type MysqlErrorSymbol = keyof typeof mysqlErrorCatalogBySymbol
 export type MysqlErrorDescriptor<Symbol extends MysqlErrorSymbol = MysqlErrorSymbol> = (typeof mysqlErrorCatalogBySymbol)[Symbol]
 export type MysqlErrorNumber = keyof typeof mysqlErrorCatalogByNumber
 export type MysqlErrorTag<Symbol extends MysqlErrorSymbol = MysqlErrorSymbol> = MysqlErrorDescriptor<Symbol>["tag"]
 export type MysqlErrorDescriptorsByNumber<Number extends MysqlErrorNumber = MysqlErrorNumber> = (typeof mysqlErrorCatalogByNumber)[Number]
 
-export const isMysqlErrorSymbol = (value: string): value is MysqlErrorSymbol => mysqlSymbolPattern.test(value)
-export const isMysqlErrorNumber = (value: string): value is MysqlErrorNumber => mysqlNumberPattern.test(value)
+export const isMysqlErrorSymbol = (value: string): value is MysqlErrorSymbol =>
+  value in mysqlErrorCatalogBySymbol
+
+export const isMysqlErrorNumber = (value: string): value is MysqlErrorNumber =>
+  value in mysqlErrorCatalogByNumber
 
 export const getMysqlErrorDescriptor = <Symbol extends MysqlErrorSymbol>(symbol: Symbol): MysqlErrorDescriptor<Symbol> =>
   mysqlErrorCatalogBySymbol[symbol]

package/src/mysql/errors/normalize.ts

@@ -48,8 +48,8 @@ const asNumber = (value: unknown): number | undefined => {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value
   }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value)
+  if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim())) {
+    const parsed = Number(value.trim())
     return Number.isFinite(parsed) ? parsed : undefined
   }
   return undefined