effect-qb 4.0.0-beta.66 → 4.0.0-beta.92

package/src/mysql/column-extension.ts

@@ -0,0 +1,3 @@
+export { custom } from "./column.js"
+
+export type { Any, AnyBound } from "./column.js"

package/src/mysql/column.ts

@@ -3,6 +3,8 @@ import * as Schema from "effect/Schema"
 import * as BaseColumn from "../internal/column.js"
 import { makeColumnDefinition, type AnyColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
 import type * as Expression from "../internal/scalar.js"
+import type { NonEmptyStringInput } from "../internal/table-options.js"
+import { enrichDbType } from "../internal/datatypes/enrich.js"
 import {
   DecimalStringSchema,
   LocalDateStringSchema,
@@ -13,13 +15,6 @@ import {
 } 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>,
   dbType: Db
@@ -51,7 +46,7 @@ export const custom = <SchemaType extends Schema.Top, Db extends Expression.DbTy
   dbType: Db
 ) =>
   makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
-    dbType: enrichDbType(dbType),
+    dbType: enrichDbType(mysqlDatatypes, dbType),
     nullable: false,
     hasDefault: false,
     generated: false,
@@ -106,10 +101,14 @@ type MysqlUniqueOptions = {
   readonly initiallyDeferred?: never
 }
 
+type NonEmptyOptionNameInput<Options> = Options extends { readonly name: infer Name extends string }
+  ? NonEmptyStringInput<Name> extends never ? never : unknown
+  : unknown
+
 type UniqueModifier = {
   <Column extends AnyColumnDefinition>(column: Column): UniqueColumn<Column>
   readonly options: <const Options extends MysqlUniqueOptions>(
-    options: Options
+    options: Options & NonEmptyOptionNameInput<Options>
   ) => <Column extends AnyColumnDefinition>(column: Column) => UniqueColumn<Column>
 }
 

package/src/mysql/datatypes/index.ts

@@ -1,5 +1,6 @@
 import type { DatatypeModule } from "../../internal/datatypes/define.js"
 import type * as Expression from "../../internal/scalar.js"
+import type { NonEmptyStringInput } from "../../internal/table-options.js"
 import { mysqlDatatypeFamilies, mysqlDatatypeKinds } from "./spec.js"
 
 const withMetadata = <Kind extends keyof typeof mysqlDatatypeKinds & string>(
@@ -14,14 +15,15 @@ const withMetadata = <Kind extends keyof typeof mysqlDatatypeKinds & string>(
     runtime: kindSpec.runtime,
     compareGroup: familySpec?.compareGroup,
     castTargets: familySpec?.castTargets,
+    implicitTargets: (familySpec as { readonly implicitTargets?: readonly string[] }).implicitTargets,
     traits: familySpec?.traits
   }
 }
 
 const mysqlDatatypeModule = {
-  custom: (kind: string) => ({
+  custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => ({
     dialect: "mysql",
-    kind
+    kind: kind as Kind
   }),
   uuid: () => ({
     dialect: "mysql",

package/src/mysql/datatypes/spec.ts

@@ -1,180 +1,10 @@
-import type { DatatypeFamilySpec, DatatypeKindSpec } from "../../internal/datatypes/shape.js"
+import {
+  mysqlDatatypeFamilies as matrixMysqlDatatypeFamilies,
+  mysqlDatatypeKinds as matrixMysqlDatatypeKinds
+} from "../../internal/datatypes/matrix.js"
 
-export const mysqlDatatypeFamilies = {
-  text: {
-    compareGroup: "text",
-    castTargets: [
-      "text",
-      "numeric",
-      "boolean",
-      "date",
-      "time",
-      "datetime",
-      "timestamp",
-      "year",
-      "binary",
-      "json",
-      "bit",
-      "enum",
-      "set",
-      "null"
-    ],
-    traits: {
-      textual: true,
-      ordered: true
-    }
-  },
-  numeric: {
-    compareGroup: "numeric",
-    castTargets: ["numeric", "text", "boolean", "date", "time", "datetime", "timestamp", "year", "bit"],
-    traits: {
-      ordered: true
-    }
-  },
-  boolean: {
-    compareGroup: "boolean",
-    castTargets: ["boolean", "text", "numeric"],
-    traits: {}
-  },
-  bit: {
-    compareGroup: "bit",
-    castTargets: ["bit", "text", "numeric"],
-    traits: {}
-  },
-  date: {
-    compareGroup: "date",
-    castTargets: ["date", "datetime", "timestamp", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  time: {
-    compareGroup: "time",
-    castTargets: ["time", "datetime", "timestamp", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  datetime: {
-    compareGroup: "datetime",
-    castTargets: ["datetime", "timestamp", "date", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  timestamp: {
-    compareGroup: "timestamp",
-    castTargets: ["timestamp", "datetime", "date", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  year: {
-    compareGroup: "year",
-    castTargets: ["year", "text", "numeric"],
-    traits: {
-      ordered: true
-    }
-  },
-  binary: {
-    compareGroup: "binary",
-    castTargets: ["binary", "text"],
-    traits: {}
-  },
-  json: {
-    compareGroup: "json",
-    castTargets: ["json", "text"],
-    traits: {}
-  },
-  spatial: {
-    compareGroup: "spatial",
-    castTargets: ["spatial", "text"],
-    traits: {}
-  },
-  enum: {
-    compareGroup: "enum",
-    castTargets: ["enum", "text"],
-    traits: {
-      textual: true,
-      ordered: true
-    }
-  },
-  set: {
-    compareGroup: "set",
-    castTargets: ["set", "text"],
-    traits: {
-      textual: true
-    }
-  },
-  null: {
-    compareGroup: "null",
-    castTargets: [
-      "text",
-      "numeric",
-      "boolean",
-      "bit",
-      "date",
-      "time",
-      "datetime",
-      "timestamp",
-      "year",
-      "binary",
-      "json",
-      "spatial",
-      "enum",
-      "set",
-      "null"
-    ],
-    traits: {}
-  }
-} as const satisfies Record<string, DatatypeFamilySpec>
-
-export const mysqlDatatypeKinds = {
-  char: { family: "text", runtime: "string" },
-  varchar: { family: "text", runtime: "string" },
-  tinytext: { family: "text", runtime: "string" },
-  text: { family: "text", runtime: "string" },
-  mediumtext: { family: "text", runtime: "string" },
-  longtext: { family: "text", runtime: "string" },
-  tinyint: { family: "numeric", runtime: "number" },
-  smallint: { family: "numeric", runtime: "number" },
-  mediumint: { family: "numeric", runtime: "number" },
-  int: { family: "numeric", runtime: "number" },
-  integer: { family: "numeric", runtime: "number" },
-  bigint: { family: "numeric", runtime: "bigintString" },
-  decimal: { family: "numeric", runtime: "decimalString" },
-  dec: { family: "numeric", runtime: "decimalString" },
-  numeric: { family: "numeric", runtime: "decimalString" },
-  fixed: { family: "numeric", runtime: "decimalString" },
-  float: { family: "numeric", runtime: "number" },
-  double: { family: "numeric", runtime: "number" },
-  real: { family: "numeric", runtime: "number" },
-  bool: { family: "boolean", runtime: "boolean" },
-  boolean: { family: "boolean", runtime: "boolean" },
-  bit: { family: "bit", runtime: "string" },
-  date: { family: "date", runtime: "localDate" },
-  time: { family: "time", runtime: "localTime" },
-  datetime: { family: "datetime", runtime: "localDateTime" },
-  timestamp: { family: "timestamp", runtime: "localDateTime" },
-  year: { family: "year", runtime: "year" },
-  binary: { family: "binary", runtime: "bytes" },
-  varbinary: { family: "binary", runtime: "bytes" },
-  tinyblob: { family: "binary", runtime: "bytes" },
-  blob: { family: "binary", runtime: "bytes" },
-  mediumblob: { family: "binary", runtime: "bytes" },
-  longblob: { family: "binary", runtime: "bytes" },
-  json: { family: "json", runtime: "json" },
-  geometry: { family: "spatial", runtime: "unknown" },
-  point: { family: "spatial", runtime: "unknown" },
-  linestring: { family: "spatial", runtime: "unknown" },
-  polygon: { family: "spatial", runtime: "unknown" },
-  multipoint: { family: "spatial", runtime: "unknown" },
-  multilinestring: { family: "spatial", runtime: "unknown" },
-  multipolygon: { family: "spatial", runtime: "unknown" },
-  geometrycollection: { family: "spatial", runtime: "unknown" },
-  enum: { family: "enum", runtime: "string" },
-  set: { family: "set", runtime: "string" }
-} as const satisfies Record<string, DatatypeKindSpec>
+export const mysqlDatatypeFamilies = matrixMysqlDatatypeFamilies
+export const mysqlDatatypeKinds = matrixMysqlDatatypeKinds
 
 export type MysqlDatatypeFamily = keyof typeof mysqlDatatypeFamilies
 export type MysqlDatatypeKind = keyof typeof mysqlDatatypeKinds

package/src/mysql/executor.ts

@@ -6,6 +6,7 @@ import * as CoreExecutor from "../internal/executor.js"
 import * as CoreQuery from "../internal/query.js"
 import * as CoreRenderer from "../internal/renderer.js"
 import type * as Expression from "../internal/scalar.js"
+import type { MysqlDatatypeFamily, MysqlDatatypeKind } from "./datatypes/spec.js"
 import { renderMysqlPlan } from "./internal/renderer.js"
 import {
   narrowMysqlDriverErrorForReadQuery,
@@ -24,12 +25,13 @@ export type Driver<Error = never, Context = never> = CoreExecutor.Driver<"mysql"
 export type Executor<Error = never, Context = never> = CoreExecutor.Executor<"mysql", Error, Context>
 /** MySQL-specialized renderer contract. */
 export type Renderer = CoreRenderer.Renderer<"mysql">
+export type ValueMappings = Expression.DriverValueMappingsFor<MysqlDatatypeKind | "uuid", MysqlDatatypeFamily | "uuid">
 /** Optional renderer / driver overrides for the standard MySQL executor pipeline. */
 export interface MakeOptions<Error = never, Context = never> {
   readonly renderer?: Renderer
   readonly driver?: Driver<Error, Context>
   readonly driverMode?: CoreExecutor.DriverMode
-  readonly valueMappings?: Expression.DriverValueMappings
+  readonly valueMappings?: ValueMappings
 }
 /** Standard composed error shape for MySQL executors. */
 export type MysqlExecutorError = MysqlDriverError | RowDecodeError
@@ -39,8 +41,6 @@ export type MysqlQueryError<PlanValue extends CoreQuery.QueryPlan<any, any, any,
 
 /** Runs an effect within the ambient MySQL SQL transaction service. */
 export const withTransaction = CoreExecutor.withTransaction
-/** Runs an effect in a nested MySQL SQL transaction scope. */
-export const withSavepoint = CoreExecutor.withSavepoint
 
 /** MySQL executor whose error channel narrows based on the query plan. */
 export interface QueryExecutor<Context = never> {
@@ -172,7 +172,7 @@ export function make(
   options: {
     readonly renderer?: Renderer
     readonly driverMode?: CoreExecutor.DriverMode
-    readonly valueMappings?: Expression.DriverValueMappings
+    readonly valueMappings?: ValueMappings
   }
 ): QueryExecutor<SqlClient.SqlClient>
 export function make<Error = never, Context = never>(
@@ -180,7 +180,7 @@ export function make<Error = never, Context = never>(
     readonly renderer?: Renderer
     readonly driver: Driver<Error, Context>
     readonly driverMode?: CoreExecutor.DriverMode
-    readonly valueMappings?: Expression.DriverValueMappings
+    readonly valueMappings?: ValueMappings
   }
 ): QueryExecutor<Context>
 export function make<Error = never, Context = never>(
@@ -188,14 +188,14 @@ export function make<Error = never, Context = never>(
 ): QueryExecutor<any> {
   if (options.driver) {
     return fromDriver(
-      options.renderer ?? CoreRenderer.make("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options.valueMappings })),
+      options.renderer ?? CoreRenderer.makeTrusted("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options.valueMappings })),
       options.driver,
       options.driverMode,
       options.valueMappings
     )
   }
   return fromDriver(
-    options.renderer ?? CoreRenderer.make("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options.valueMappings })),
+    options.renderer ?? CoreRenderer.makeTrusted("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options.valueMappings })),
     sqlClientDriver(),
     options.driverMode,
     options.valueMappings

package/src/mysql/internal/dialect.ts

@@ -1,7 +1,9 @@
-import type { RenderState, RenderValueContext, SqlDialect } from "../../internal/dialect.js"
+import { quoteBacktickIdentifier, type RenderState, type RenderValueContext, type SqlDialect } from "../../internal/dialect.js"
+import { renderExpression, renderQueryAst } from "../../internal/dialect-renderers/mysql.js"
 import { toDriverValue } from "../../internal/runtime/driver-value-mapping.js"
+import { standardDialect } from "../../standard/dialect.js"
 
-const quoteIdentifier = (value: string): string => `\`${value.replaceAll("`", "``")}\``
+const quoteIdentifier = quoteBacktickIdentifier
 
 const renderLiteral = (value: unknown, state: RenderState, context: RenderValueContext = {}): string => {
   const driverValue = toDriverValue(value, {
@@ -28,11 +30,12 @@ const renderLiteral = (value: unknown, state: RenderState, context: RenderValueC
  * grows.
  */
 export const mysqlDialect: SqlDialect<"mysql"> = {
+  ...standardDialect,
   name: "mysql",
   quoteIdentifier,
   renderLiteral,
   renderTableReference(tableName, baseTableName, schemaName) {
-    const renderedBase = schemaName
+    const renderedBase = schemaName && schemaName !== "public"
       ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}`
       : quoteIdentifier(baseTableName)
     return tableName === baseTableName
@@ -41,5 +44,7 @@ export const mysqlDialect: SqlDialect<"mysql"> = {
   },
   renderConcat(values) {
     return `concat(${values.join(", ")})`
-  }
+  },
+  renderQueryAst,
+  renderExpression
 }