effect-qb 0.14.0 → 0.15.0

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

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