effect-qb 0.14.0 → 0.16.0

package/src/internal/table.d.ts

@@ -0,0 +1,173 @@
+import { type Pipeable } from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import * as Plan from "./row-set.js";
+import type { TrueFormula } from "./predicate/formula.js";
+import type { BoundColumnFrom } from "./column-state.js";
+import { type DdlExpressionLike, type NormalizeColumns, type TableOptionSpec, type ValidateKnownColumns, type ValidatePrimaryKeyColumns } from "./table-options.js";
+import { type InsertRow, type SelectRow, type TableFieldMap, type UpdateRow } from "./schema-derivation.js";
+/** Symbol used to attach table-definition metadata. */
+export declare const TypeId: unique symbol;
+/** Symbol for the normalized table option list. */
+export declare const OptionsSymbol: unique symbol;
+/** Symbol used by `Table.Class` to declare table-level options. */
+export declare const options: unique symbol;
+declare const DeclaredOptionsSymbol: unique symbol;
+type InlinePrimaryKeyKeys<Fields extends TableFieldMap> = Extract<{
+    [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never;
+}[keyof Fields], string>;
+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";
+}>;
+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 BuildPrimaryKey<Table extends TableDefinition<any, any, any, "schema", any>, Spec extends TableOptionSpec> = Spec extends {
+    readonly kind: "primaryKey";
+    readonly columns: infer Columns extends readonly string[];
+} ? Columns[number] & keyof Table[typeof TypeId]["fields"] & string : Table[typeof TypeId]["primaryKey"][number];
+type OptionInputTable<Table extends TableDefinition<any, any, any, "schema", any>, 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;
+type ApplyOption<Table extends TableDefinition<any, any, any, "schema", any>, Spec extends TableOptionSpec> = Spec extends {
+    readonly kind: "primaryKey";
+} ? TableDefinition<Table[typeof TypeId]["name"], Table[typeof TypeId]["fields"], BuildPrimaryKey<Table, Spec>, "schema"> : TableDefinition<Table[typeof TypeId]["name"], Table[typeof TypeId]["fields"], Table[typeof TypeId]["primaryKey"][number], "schema">;
+export type MissingSelfGeneric = "Missing `Self` generic - use `class Self extends Table.Class<Self>(...) {}`";
+/** Bound columns keyed by field name for a particular table. */
+export type BoundColumns<Name extends string, Fields extends TableFieldMap> = {
+    readonly [K in keyof Fields]: BoundColumnFrom<Fields[K], Name, Extract<K, string>>;
+};
+/** Derived runtime schemas exposed by a table definition. */
+export interface TableSchemas<Name extends string, 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>>;
+}
+interface TableState<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string, Kind extends TableKind = "schema", SchemaName extends string | undefined = DefaultSchemaName> {
+    readonly name: Name;
+    readonly baseName: string;
+    readonly schemaName: SchemaName;
+    readonly fields: Fields;
+    readonly primaryKey: readonly PrimaryKeyColumns[];
+    readonly kind: Kind;
+}
+/** Namespace-scoped table builder. */
+export interface TableSchemaNamespace<SchemaName extends string> {
+    readonly schemaName: SchemaName;
+    readonly table: <Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>>(name: Name, fields: Fields, ...options: DeclaredTableOptions) => TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>;
+}
+export type DeclaredTableOptions = readonly TableOptionBuilderLike[];
+export type { DdlExpressionLike, IndexKeySpec, NormalizeColumns, ReferentialAction } from "./table-options.js";
+export type TableDefinition<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>, Kind extends TableKind = "schema", SchemaName extends string | undefined = DefaultSchemaName> = Pipeable & {
+    readonly name: Name;
+    readonly columns: BoundColumns<Name, Fields>;
+    readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>;
+    readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, Kind, SchemaName>;
+    readonly [Plan.TypeId]: Plan.State<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
+    readonly [OptionsSymbol]: readonly TableOptionSpec[];
+    readonly [DeclaredOptionsSymbol]: readonly TableOptionSpec[];
+} & BoundColumns<Name, Fields> & Plan.RowSet<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
+/**
+ * Static class-based table definition.
+ *
+ * The class object itself acts as the table definition, exposing static bound
+ * columns, derived schemas, and plan metadata.
+ */
+export type TableClassStatic<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>, SchemaName extends string | undefined = DefaultSchemaName> = (abstract new (...args: any[]) => any) & Pipeable & {
+    readonly columns: BoundColumns<Name, Fields>;
+    readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>;
+    readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>;
+    readonly [Plan.TypeId]: Plan.State<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
+    readonly [OptionsSymbol]: readonly TableOptionSpec[];
+    readonly [DeclaredOptionsSymbol]?: readonly TableOptionSpec[];
+    readonly [options]?: ClassDeclaredTableOptions;
+    readonly tableName: Name;
+} & BoundColumns<Name, Fields> & Plan.RowSet<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
+/** Minimal structural table-like contract used across helper APIs. */
+export type AnyTable = TableDefinition<any, any, any, any, any> | TableClassStatic<any, any, any, any>;
+/** Public table-option builder type used by `Table.index`, `Table.primaryKey`, and friends. */
+export type TableOption<Spec extends TableOptionSpec = TableOptionSpec> = {
+    <Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(table: OptionInputTable<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", any>, Spec>): ApplyOption<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", any>, Spec>;
+    readonly option: Spec;
+};
+export declare const option: <Spec extends TableOptionSpec>(spec: Spec) => TableOption<Spec>;
+export declare const optionFromTable: <Spec extends TableOptionSpec>(spec: Spec, resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec) => TableOption<Spec>;
+/** Creates a table definition from a name and field map. */
+export declare function make<Name extends string, Fields extends TableFieldMap, SchemaName extends string | undefined = DefaultSchemaName>(name: Name, fields: Fields, schemaName?: SchemaName): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", SchemaName>;
+/**
+ * Creates a namespace-scoped builder for a concrete SQL schema/database.
+ */
+export declare const schema: <SchemaName extends string>(schemaName: SchemaName) => TableSchemaNamespace<SchemaName>;
+/**
+ * Creates an aliased source from an existing table definition.
+ *
+ * The alias becomes the logical source identity used by the query layer while
+ * the original physical table name is retained in bound-column provenance for
+ * downstream SQL rendering work.
+ */
+export declare const alias: <Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string, SchemaName extends string, AliasName extends string>(table: TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName> | TableDefinition<Name, Fields, PrimaryKeyColumns, any, SchemaName>, aliasName: AliasName) => TableDefinition<AliasName, Fields, PrimaryKeyColumns, "alias", SchemaName>;
+/**
+ * Class-based table constructor mirroring `Schema.Class`.
+ *
+ * The returned base class can be extended and configured with
+ * `static readonly [Table.options]`.
+ */
+export declare function Class<Self = never, SchemaName extends string | undefined = DefaultSchemaName>(name: string, schemaName?: SchemaName): <Fields extends TableFieldMap>(fields: Fields) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Table.Class<Self>(...) {}`" : TableClassStatic<string, Fields, Extract<{ [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never; }[keyof Fields], string>, SchemaName>;
+/** Declares a table-level primary key. */
+export declare const primaryKey: <const Columns extends string | readonly string[]>(columns: Columns) => TableOption<{
+    readonly kind: "primaryKey";
+    readonly columns: NormalizeColumns<Columns>;
+}>;
+/** Declares a table-level unique constraint. */
+export declare const unique: <const Columns extends string | readonly string[]>(columns: Columns) => TableOption<{
+    readonly kind: "unique";
+    readonly columns: NormalizeColumns<Columns>;
+}>;
+/** Declares a table-level index. */
+export declare const index: <const Columns extends string | readonly string[]>(columns: Columns) => TableOption<{
+    readonly kind: "index";
+    readonly columns: NormalizeColumns<Columns>;
+}>;
+/** Declares a table-level foreign key. */
+export declare const foreignKey: <const LocalColumns extends string | readonly string[], TargetTable extends AnyTable, const TargetColumns extends string | readonly string[]>(columns: LocalColumns, target: () => TargetTable, referencedColumns: TargetColumns) => TableOption<{
+    readonly kind: "foreignKey";
+    readonly columns: NormalizeColumns<LocalColumns>;
+    readonly references: () => {
+        readonly tableName: string;
+        readonly schemaName?: string | undefined;
+        readonly columns: NormalizeColumns<TargetColumns>;
+        readonly knownColumns: readonly string[];
+    };
+}>;
+/** Declares a check constraint expression. */
+export declare const check: <Name extends string>(name: Name, predicate: DdlExpressionLike) => TableOption<{
+    readonly kind: "check";
+    readonly name: Name;
+    readonly predicate: DdlExpressionLike;
+}>;
+/** 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"]>;

package/src/internal/table.ts

@@ -1,9 +1,9 @@
 import { pipeArguments, type Pipeable } from "effect/Pipeable"
 import * as Schema from "effect/Schema"
 
-import * as Plan from "./plan.js"
-import type { Any as AnyExpression } from "./expression.js"
-import type { TrueFormula } from "./predicate-formula.js"
+import * as Plan from "./row-set.js"
+import type { Any as AnyExpression } from "./scalar.js"
+import type { TrueFormula } from "./predicate/formula.js"
 import type { BoundColumnFrom } from "./column-state.js"
 import { bindColumn, type AnyColumnDefinition } from "./column-state.js"
 import {
@@ -76,12 +76,19 @@ type OptionInputTable<
 type ApplyOption<
   Table extends TableDefinition<any, any, any, "schema", any>,
   Spec extends TableOptionSpec
-> = TableDefinition<
-  Table[typeof TypeId]["name"],
-  Table[typeof TypeId]["fields"],
-  BuildPrimaryKey<Table, Spec>,
-  "schema"
->
+> = Spec extends { readonly kind: "primaryKey" }
+  ? TableDefinition<
+    Table[typeof TypeId]["name"],
+    Table[typeof TypeId]["fields"],
+    BuildPrimaryKey<Table, Spec>,
+    "schema"
+  >
+  : TableDefinition<
+    Table[typeof TypeId]["name"],
+    Table[typeof TypeId]["fields"],
+    Table[typeof TypeId]["primaryKey"][number],
+    "schema"
+  >
 
 export type MissingSelfGeneric = "Missing `Self` generic - use `class Self extends Table.Class<Self>(...) {}`"
 
@@ -155,7 +162,7 @@ export type TableDefinition<
   >
   readonly [OptionsSymbol]: readonly TableOptionSpec[]
   readonly [DeclaredOptionsSymbol]: readonly TableOptionSpec[]
-} & BoundColumns<Name, Fields> & Plan.Plan<
+} & BoundColumns<Name, Fields> & Plan.RowSet<
     BoundColumns<Name, Fields>,
     never,
     Record<Name, Plan.Source<Name, "required", TrueFormula>>,
@@ -187,7 +194,7 @@ export type TableClassStatic<
   readonly [DeclaredOptionsSymbol]?: readonly TableOptionSpec[]
   readonly [options]?: ClassDeclaredTableOptions
   readonly tableName: Name
-} & BoundColumns<Name, Fields> & Plan.Plan<
+} & BoundColumns<Name, Fields> & Plan.RowSet<
     BoundColumns<Name, Fields>,
     never,
     Record<Name, Plan.Source<Name, "required", TrueFormula>>,
@@ -217,6 +224,17 @@ const TableProto = {
   }
 }
 
+const attachPipe = <Value extends object>(value: Value): Value => {
+  Object.defineProperty(value, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function(this: unknown) {
+      return pipeArguments(value, arguments)
+    }
+  })
+  return value
+}
+
 type BuildArtifacts<
   Name extends string,
   Fields extends TableFieldMap,
@@ -274,7 +292,7 @@ const makeTable = <
     : ("public" as SchemaName)
   const artifacts = buildArtifacts(name, fields, declaredOptions, resolvedSchemaName)
   const dialect = resolveFieldDialect(fields)
-  const table = Object.create(TableProto)
+  const table = attachPipe(Object.create(TableProto))
   table.name = name
   table.columns = artifacts.columns
   table.schemas = artifacts.schemas
@@ -339,7 +357,7 @@ const validateClassOptions = (declaredOptions: readonly TableOptionSpec[]): void
 const resolveFieldDialect = (fields: TableFieldMap): string => {
   const dialects = [...new Set(Object.values(fields).map((field) => field.metadata.dbType.dialect))]
   if (dialects.length === 0) {
-    return "postgres"
+    throw new Error("Cannot infer table dialect from an empty field set")
   }
   if (dialects.length > 1) {
     throw new Error(`Mixed table dialects are not supported: ${dialects.join(", ")}`)
@@ -525,7 +543,7 @@ export const alias = <
   const columns = Object.fromEntries(
     Object.entries(state.fields).map(([key, column]) => [key, bindColumn(aliasName, key, column as AnyColumnDefinition, state.baseName, state.schemaName)])
   ) as BoundColumns<AliasName, Fields>
-  const aliased = Object.create(TableProto)
+  const aliased = attachPipe(Object.create(TableProto))
   aliased.name = aliasName
   aliased.columns = columns
   aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey)

package/src/mysql/column.ts

@@ -1,22 +1,98 @@
+import * as Schema from "effect/Schema"
+
 import * as BaseColumn from "../internal/column.js"
-import * as Expression from "../internal/expression.js"
-import { LocalDateTimeStringSchema } from "../internal/runtime-value.js"
-
-/** MySQL-specialized column-definition DSL. */
-export const uuid = BaseColumn.mysql.uuid
-export const text = BaseColumn.mysql.text
-export const int = BaseColumn.mysql.int
-export const number = BaseColumn.mysql.number
-export const boolean = BaseColumn.mysql.boolean
-export const date = BaseColumn.mysql.date
-export const datetime = () =>
-  BaseColumn.mysql.custom(
-    LocalDateTimeStringSchema,
-    { dialect: "mysql", kind: "datetime" } as Expression.DbType.MySqlDatetime
-  )
-export const timestamp = BaseColumn.mysql.timestamp
-export const json = BaseColumn.mysql.json
-export const custom = BaseColumn.mysql.custom
+import { makeColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
+import type * as Expression from "../internal/scalar.js"
+import {
+  DecimalStringSchema,
+  LocalDateStringSchema,
+  LocalDateTimeStringSchema,
+  type DecimalString,
+  type LocalDateString,
+  type LocalDateTimeString
+} from "../internal/runtime/value.js"
+import { mysqlDatatypes } from "./datatypes/index.js"
+
+const enrichDbType = <Db extends Expression.DbType.Any>(dbType: Db): Db => {
+  const candidate = (mysqlDatatypes 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, mysqlDatatypes.uuid())
+export const text = () => primitive(Schema.String, mysqlDatatypes.text())
+export const int = () => primitive(Schema.Int, mysqlDatatypes.int())
+export const number = (options?: BaseColumn.NumericOptions) =>
+  makeColumnDefinition(DecimalStringSchema, {
+    dbType: mysqlDatatypes.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, 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>, {
+    dbType: { ...mysqlDatatypes.json(), variant: "json" } as Expression.DbType.Json<"mysql", "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
@@ -24,6 +100,7 @@ export const primaryKey = BaseColumn.primaryKey
 export const unique = BaseColumn.unique
 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 }

package/src/mysql/datatypes/index.ts

@@ -1,21 +1,61 @@
 import type { DatatypeModule } from "../../internal/datatypes/define.js"
-import type * as Expression from "../../internal/expression.js"
-import { mysqlDatatypeKinds } from "./spec.js"
+import type * as Expression from "../../internal/scalar.js"
+import { mysqlDatatypeFamilies, mysqlDatatypeKinds } from "./spec.js"
+
+const withMetadata = <Kind extends keyof typeof mysqlDatatypeKinds & string>(
+  kind: Kind
+): Expression.DbType.Base<"mysql", Kind> => {
+  const kindSpec = mysqlDatatypeKinds[kind]
+  const familySpec = mysqlDatatypeFamilies[kindSpec.family as keyof typeof mysqlDatatypeFamilies]
+  return {
+    dialect: "mysql",
+    kind,
+    family: kindSpec.family,
+    runtime: kindSpec.runtime,
+    compareGroup: familySpec?.compareGroup,
+    castTargets: familySpec?.castTargets,
+    traits: familySpec?.traits
+  }
+}
 
 const mysqlDatatypeModule = {
   custom: (kind: string) => ({
     dialect: "mysql",
     kind
+  }),
+  uuid: () => ({
+    dialect: "mysql",
+    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<"mysql", string>>
 
 for (const kind of Object.keys(mysqlDatatypeKinds)) {
-  mysqlDatatypeModule[kind] = () => ({
-    dialect: "mysql",
-    kind
-  })
+  mysqlDatatypeModule[kind] = () => withMetadata(kind as keyof typeof mysqlDatatypeKinds & string)
 }
 
-export const mysqlDatatypes = mysqlDatatypeModule as DatatypeModule<"mysql", typeof mysqlDatatypeKinds>
+type MysqlUuidWitness = Expression.DbType.Base<"mysql", "uuid"> & {
+  readonly family: "uuid"
+  readonly runtime: "string"
+  readonly compareGroup: "uuid"
+  readonly castTargets: readonly ["uuid", "char", "varchar", "text"]
+  readonly traits: {
+    readonly textual: true
+  }
+}
+
+export const mysqlDatatypes = mysqlDatatypeModule as DatatypeModule<
+  "mysql",
+  typeof mysqlDatatypeKinds,
+  typeof mysqlDatatypeFamilies
+> & {
+  readonly uuid: () => MysqlUuidWitness
+}
 
 export type MysqlDatatypeModule = typeof mysqlDatatypes