effect-qb 0.13.0 → 0.15.0

package/src/internal/table.ts

@@ -1,16 +1,19 @@
 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 * 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 {
   collectInlineOptions,
   normalizeColumnList,
   resolvePrimaryKeyColumns,
-  type DeclaredTableOptions as InternalDeclaredTableOptions,
+  type DdlExpressionLike,
+  type IndexKeySpec,
   type NormalizeColumns,
+  type ReferentialAction,
   type TableOptionSpec,
   type ValidateKnownColumns,
   type ValidatePrimaryKeyColumns,
@@ -42,7 +45,16 @@ type TableDialect<Fields extends TableFieldMap> = Fields[keyof Fields][typeof im
 type TableKind = "schema" | "alias"
 type DefaultSchemaName = "public"
 type ClassOptionSpec = Exclude<TableOptionSpec, { readonly kind: "primaryKey" }>
-type ClassTableOption = TableOption<ClassOptionSpec>
+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<
@@ -64,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>(...) {}`"
 
@@ -83,12 +102,13 @@ export type BoundColumns<
 
 /** 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<Fields>>
-  readonly insert: Schema.Schema<InsertRow<Fields>>
-  readonly update: Schema.Schema<UpdateRow<Fields, PrimaryKeyColumns>>
+  readonly select: Schema.Schema<SelectRow<Name, Fields>>
+  readonly insert: Schema.Schema<InsertRow<Name, Fields>>
+  readonly update: Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>
 }
 
 interface TableState<
@@ -116,11 +136,12 @@ export interface TableSchemaNamespace<SchemaName extends string> {
   >(
     name: Name,
     fields: Fields,
-    ...options: InternalDeclaredTableOptions
+    ...options: DeclaredTableOptions
   ) => TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
 }
 
-export type DeclaredTableOptions = InternalDeclaredTableOptions
+export type DeclaredTableOptions = readonly TableOptionBuilderLike[]
+export type { DdlExpressionLike, IndexKeySpec, NormalizeColumns, ReferentialAction } from "./table-options.js"
 
 export type TableDefinition<
   Name extends string,
@@ -131,20 +152,20 @@ export type TableDefinition<
 > = Pipeable & {
   readonly name: Name
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Fields, PrimaryKeyColumns>
+  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>>,
+    Record<Name, Plan.Source<Name, "required", TrueFormula>>,
     TableDialect<Fields>
   >
   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>>,
+    Record<Name, Plan.Source<Name, "required", TrueFormula>>,
     TableDialect<Fields>
   >
 
@@ -161,22 +182,22 @@ export type TableClassStatic<
   SchemaName extends string | undefined = DefaultSchemaName
 > = (abstract new (...args: any[]) => any) & Pipeable & {
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Fields, PrimaryKeyColumns>
+  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>>,
+    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.Plan<
+} & BoundColumns<Name, Fields> & Plan.RowSet<
     BoundColumns<Name, Fields>,
     never,
-    Record<Name, Plan.Source<Name>>,
+    Record<Name, Plan.Source<Name, "required", TrueFormula>>,
     TableDialect<Fields>
   >
 
@@ -203,13 +224,24 @@ 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,
   PrimaryKeyColumns extends keyof Fields & string
 > = {
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Fields, PrimaryKeyColumns>
+  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
   readonly normalizedOptions: readonly TableOptionSpec[]
   readonly primaryKey: readonly PrimaryKeyColumns[]
 }
@@ -231,7 +263,7 @@ 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(fields, primaryKey)
+  const schemas = deriveSchemas(name, fields, primaryKey)
   return {
     columns,
     schemas,
@@ -260,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
@@ -299,6 +331,21 @@ const extractDeclaredOptions = (
   declaredOptions: DeclaredTableOptions | undefined
 ): readonly TableOptionSpec[] => declaredOptions?.map((option) => option.option) ?? []
 
+const applyDeclaredOptions = <
+  Table extends TableDefinition<any, any, any, "schema", any>
+>(
+  table: Table,
+  declaredOptions: DeclaredTableOptions | undefined
+): Table => {
+  if (declaredOptions === undefined || declaredOptions.length === 0) {
+    return table
+  }
+  return declaredOptions.reduce<TableDefinition<any, any, any, "schema", any>>(
+    (current, option) => option(current),
+    table
+  ) as unknown as Table
+}
+
 const validateClassOptions = (declaredOptions: readonly TableOptionSpec[]): void => {
   for (const option of declaredOptions) {
     if (option.kind === "primaryKey") {
@@ -310,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(", ")}`)
@@ -340,14 +387,26 @@ const ensureClassArtifacts = <
     return cached
   }
   const state = self[TypeId]
-  const declaredOptions = extractDeclaredOptions(self[options])
-  validateClassOptions(declaredOptions)
-  const artifacts = buildArtifacts(
-    state.name,
-    state.fields,
-    declaredOptions,
-    state.schemaName
-  ) as BuildArtifacts<Name, Fields, PrimaryKeyColumns>
+  const classOptions = self[options]
+  validateClassOptions(extractDeclaredOptions(classOptions))
+  const table = applyDeclaredOptions(
+    makeTable(
+      state.name,
+      state.fields,
+      [],
+      state.name,
+      "schema",
+      state.schemaName,
+      state.schemaName === undefined || state.schemaName === "public" ? "default" : "explicit"
+    ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", typeof state.schemaName>,
+    classOptions
+  )
+  const artifacts = {
+    columns: table.columns,
+    schemas: table.schemas,
+    normalizedOptions: table[OptionsSymbol],
+    primaryKey: table[TypeId].primaryKey as readonly PrimaryKeyColumns[]
+  } satisfies BuildArtifacts<Name, Fields, PrimaryKeyColumns>
   Object.defineProperty(self, CacheSymbol, {
     configurable: true,
     value: artifacts
@@ -384,6 +443,25 @@ const makeOption = <Spec extends TableOptionSpec>(option: Spec): TableOption<Spe
   return builder
 }
 
+const makeResolvedOption = <Spec extends TableOptionSpec>(
+  option: Spec,
+  resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec
+): TableOption<Spec> => {
+  const builder = ((table: TableDefinition<any, any, any, "schema", any>) =>
+    appendOption(table, resolve(table))) as unknown as TableOption<Spec>
+  ;(builder as { option: Spec }).option = option
+  return builder
+}
+
+export const option = <Spec extends TableOptionSpec>(spec: Spec): TableOption<Spec> =>
+  makeOption(spec)
+
+export const optionFromTable = <Spec extends TableOptionSpec>(
+  spec: Spec,
+  resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec
+): TableOption<Spec> =>
+  makeResolvedOption(spec, resolve)
+
 /** Creates a table definition from a name and field map. */
 export function make<
   Name extends string,
@@ -422,17 +500,20 @@ export const schema = <SchemaName extends string>(
   >(
     name: Name,
     fields: Fields,
-    ...options: InternalDeclaredTableOptions
+    ...options: DeclaredTableOptions
   ): TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName> =>
-    makeTable(
-      name,
-      fields,
-      extractDeclaredOptions(options),
-      name,
-      "schema",
-      schemaName,
-      "explicit"
-    ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
+    applyDeclaredOptions(
+      makeTable(
+        name,
+        fields,
+        [],
+        name,
+        "schema",
+        schemaName,
+        "explicit"
+      ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
+      options
+    )
 })
 
 /**
@@ -462,10 +543,10 @@ 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 = table.schemas
+  aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey)
   aliased[TypeId] = {
     name: aliasName,
     baseName: state.baseName,
@@ -581,7 +662,7 @@ export function Class<
 
 /** Declares a table-level primary key. */
 export const primaryKey = <
-  Columns extends string | readonly string[]
+  const Columns extends string | readonly string[]
 >(
   columns: Columns
 ): TableOption<{
@@ -594,7 +675,7 @@ export const primaryKey = <
 
 /** Declares a table-level unique constraint. */
 export const unique = <
-  Columns extends string | readonly string[]
+  const Columns extends string | readonly string[]
 >(
   columns: Columns
 ): TableOption<{
@@ -607,7 +688,7 @@ export const unique = <
 
 /** Declares a table-level index. */
 export const index = <
-  Columns extends string | readonly string[]
+  const Columns extends string | readonly string[]
 >(
   columns: Columns
 ): TableOption<{
@@ -620,9 +701,9 @@ export const index = <
 
 /** Declares a table-level foreign key. */
 export const foreignKey = <
-  LocalColumns extends string | readonly string[],
+  const LocalColumns extends string | readonly string[],
   TargetTable extends AnyTable,
-  TargetColumns extends string | readonly string[]
+  const TargetColumns extends string | readonly string[]
 >(
   columns: LocalColumns,
   target: () => TargetTable,
@@ -650,11 +731,11 @@ export const foreignKey = <
 /** Declares a check constraint expression. */
 export const check = <Name extends string>(
   name: Name,
-  predicate: AnyExpression
+  predicate: DdlExpressionLike
 ): TableOption<{
   readonly kind: "check"
   readonly name: Name
-  readonly predicate: AnyExpression
+  readonly predicate: DdlExpressionLike
 }> => makeOption({
   kind: "check",
   name,

package/src/mysql/column.ts

@@ -1,24 +1,101 @@
+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
 export const primaryKey = BaseColumn.primaryKey
 export const unique = BaseColumn.unique
 const default_ = BaseColumn.default_

package/src/mysql/datatypes/index.ts

@@ -1,6 +1,61 @@
-import { makeDatatypeModule } from "../../internal/datatypes/define.js"
-import { mysqlDatatypeKinds } from "./spec.js"
+import type { DatatypeModule } from "../../internal/datatypes/define.js"
+import type * as Expression from "../../internal/scalar.js"
+import { mysqlDatatypeFamilies, mysqlDatatypeKinds } from "./spec.js"
 
-export const mysqlDatatypes = makeDatatypeModule("mysql", mysqlDatatypeKinds)
+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] = () => withMetadata(kind as keyof typeof mysqlDatatypeKinds & string)
+}
+
+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