effect-qb 0.12.3

package/src/internal/datatypes/lookup.ts

@@ -0,0 +1,280 @@
+import type * as Expression from ".././expression.js"
+import type { mysqlDatatypeFamilies, mysqlDatatypeKinds } from "../../mysql/datatypes/spec.js"
+import type { postgresDatatypeFamilies, postgresDatatypeKinds } from "../../postgres/datatypes/spec.js"
+import type { RuntimeOfTag, RuntimeTag } from "./shape.js"
+
+type KnownDialect = "postgres" | "mysql"
+
+type DialectKinds<Dialect extends KnownDialect> =
+  Dialect extends "postgres" ? typeof postgresDatatypeKinds :
+    typeof mysqlDatatypeKinds
+
+type DialectFamilies<Dialect extends KnownDialect> =
+  Dialect extends "postgres" ? typeof postgresDatatypeFamilies :
+    typeof mysqlDatatypeFamilies
+
+type StripParameterizedKind<Kind extends string> =
+  Kind extends `${infer Base}(${string}`
+    ? StripParameterizedKind<Base>
+    : Kind
+
+type StripArrayKind<Kind extends string> =
+  Kind extends `${infer Base}[]`
+    ? StripArrayKind<Base>
+    : Kind
+
+type BaseKind<Kind extends string> = StripArrayKind<StripParameterizedKind<Kind>>
+
+type IsArrayKind<Kind extends string> = Kind extends `${string}[]` ? true : false
+
+type ExactKindFamily =
+  | "array"
+  | "range"
+  | "multirange"
+  | "record"
+  | "enum"
+  | "set"
+
+type KnownKindFamily<
+  Dialect extends KnownDialect,
+  Kind extends string
+> = IsArrayKind<Kind> extends true
+  ? "array"
+  : BaseKind<Kind> extends "null"
+    ? "null"
+    : BaseKind<Kind> extends keyof DialectKinds<Dialect>
+      ? DialectKinds<Dialect>[BaseKind<Kind>] extends { readonly family: infer Family extends string }
+        ? Family
+        : never
+      : `other:${Dialect}:${Kind}`
+
+type KnownKindRuntimeTag<
+  Dialect extends KnownDialect,
+  Kind extends string
+> = IsArrayKind<Kind> extends true
+  ? "array"
+  : BaseKind<Kind> extends "null"
+    ? "null"
+    : BaseKind<Kind> extends keyof DialectKinds<Dialect>
+      ? DialectKinds<Dialect>[BaseKind<Kind>] extends { readonly runtime: infer Runtime extends RuntimeTag }
+        ? Runtime
+        : "unknown"
+      : "unknown"
+
+type FamilyCastTargets<
+  Dialect extends KnownDialect,
+  Family extends string
+> = Family extends keyof DialectFamilies<Dialect>
+  ? DialectFamilies<Dialect>[Family] extends { readonly castTargets: readonly (infer CastTarget extends string)[] }
+    ? CastTarget
+    : never
+  : never
+
+type FamilyHasTextualTrait<
+  Dialect extends KnownDialect,
+  Family extends string
+> = Family extends keyof DialectFamilies<Dialect>
+  ? DialectFamilies<Dialect>[Family] extends { readonly traits: infer Traits }
+    ? Traits extends { readonly textual: true }
+      ? true
+      : false
+    : false
+  : false
+
+type BaseFamilyOf<
+  Dialect extends KnownDialect,
+  Kind extends string
+> = Kind extends keyof DialectKinds<Dialect>
+  ? DialectKinds<Dialect>[Kind] extends { readonly family: infer Family extends string }
+    ? Family
+    : never
+  : `other:${Dialect}:${Kind}`
+
+type BaseRuntimeTagOf<
+  Dialect extends KnownDialect,
+  Kind extends string
+> = Kind extends keyof DialectKinds<Dialect>
+  ? DialectKinds<Dialect>[Kind] extends { readonly runtime: infer Runtime extends RuntimeTag }
+    ? Runtime
+    : "unknown"
+  : "unknown"
+
+type BaseCompareGroupOf<
+  Dialect extends KnownDialect,
+  Kind extends string
+> = BaseFamilyOf<Dialect, Kind> extends ExactKindFamily
+  ? Kind
+  : BaseFamilyOf<Dialect, Kind> extends keyof DialectFamilies<Dialect>
+    ? DialectFamilies<Dialect>[BaseFamilyOf<Dialect, Kind>] extends { readonly compareGroup: infer CompareGroup extends string }
+      ? CompareGroup
+      : never
+    : BaseFamilyOf<Dialect, Kind>
+
+export type FamilyOfDbType<Db extends Expression.DbType.Any> =
+  Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
+    ? FamilyOfDbType<Base>
+    : Db extends Expression.DbType.Array<any, any, any>
+      ? "array"
+    : Db extends Expression.DbType.Range<any, any, any>
+      ? "range"
+      : Db extends Expression.DbType.Multirange<any, any, any>
+        ? "multirange"
+        : Db extends Expression.DbType.Composite<any, any, any>
+          ? "record"
+          : Db extends Expression.DbType.Enum<any, any>
+            ? "enum"
+            : Db extends Expression.DbType.Set<any, any>
+              ? "set"
+              : Db extends Expression.DbType.Json<any, any>
+                ? "json"
+              : Db extends Expression.DbType.Base<infer Dialect extends KnownDialect, infer Kind extends string>
+                ? BaseFamilyOf<Dialect, Kind>
+                : "other:unknown:unknown"
+
+export type CompareGroupOfDbType<Db extends Expression.DbType.Any> =
+  Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
+    ? CompareGroupOfDbType<Base>
+    : Db extends Expression.DbType.Array<any, any, infer Kind extends string>
+      ? Kind
+      : Db extends Expression.DbType.Range<any, any, infer Kind extends string>
+        ? Kind
+        : Db extends Expression.DbType.Multirange<any, any, infer Kind extends string>
+          ? Kind
+        : Db extends Expression.DbType.Composite<any, any, infer Kind extends string>
+            ? Kind
+            : Db extends Expression.DbType.Enum<any, infer Kind extends string>
+              ? Kind
+            : Db extends Expression.DbType.Set<any, infer Kind extends string>
+              ? Kind
+            : Db extends Expression.DbType.Json<any, any>
+              ? never
+                : Db extends Expression.DbType.Base<infer Dialect extends KnownDialect, infer Kind extends string>
+                  ? BaseCompareGroupOf<Dialect, Kind>
+                  : "other:unknown:unknown"
+
+export type RuntimeOfDbType<Db extends Expression.DbType.Any> =
+  Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
+    ? RuntimeOfDbType<Base>
+    : Db extends Expression.DbType.Array<any, infer Element extends Expression.DbType.Any, any>
+      ? ReadonlyArray<RuntimeOfDbType<Element>>
+      : Db extends Expression.DbType.Composite<any, infer Fields extends Record<string, Expression.DbType.Any>, any>
+        ? { readonly [K in keyof Fields]: RuntimeOfDbType<Fields[K]> }
+      : Db extends Expression.DbType.Range<any, any, any> | Expression.DbType.Multirange<any, any, any>
+        ? unknown
+        : Db extends Expression.DbType.Json<any, any>
+          ? import("../runtime-value.js").JsonValue
+            : Db extends Expression.DbType.Enum<any, any> | Expression.DbType.Set<any, any>
+            ? string
+            : Db extends Expression.DbType.Base<infer Dialect extends KnownDialect, infer Kind extends string>
+              ? BaseRuntimeTagOf<Dialect, Kind> extends infer Runtime extends RuntimeTag
+                ? RuntimeOfTag<Runtime>
+                : unknown
+              : unknown
+
+export type CanCompareDbTypes<
+  Left extends Expression.DbType.Any,
+  Right extends Expression.DbType.Any,
+  Dialect extends string
+> = Left extends { readonly dialect: Dialect }
+  ? Right extends { readonly dialect: Dialect }
+    ? CompareGroupOfDbType<Left> extends never
+      ? false
+      : CompareGroupOfDbType<Right> extends never
+        ? false
+        : CompareGroupOfDbType<Left> extends "null"
+          ? false
+          : CompareGroupOfDbType<Right> extends "null"
+            ? false
+            : [CompareGroupOfDbType<Left>] extends [CompareGroupOfDbType<Right>]
+              ? [CompareGroupOfDbType<Right>] extends [CompareGroupOfDbType<Left>]
+                ? true
+                : false
+              : false
+    : false
+  : false
+
+export type CanContainDbTypes<
+  Left extends Expression.DbType.Any,
+  Right extends Expression.DbType.Any,
+  Dialect extends string
+> = Left extends { readonly dialect: Dialect }
+  ? Right extends { readonly dialect: Dialect }
+    ? FamilyOfDbType<Left> extends "array" | "range" | "multirange"
+      ? FamilyOfDbType<Right> extends "array" | "range" | "multirange"
+        ? [CompareGroupOfDbType<Left>] extends [CompareGroupOfDbType<Right>]
+          ? [CompareGroupOfDbType<Right>] extends [CompareGroupOfDbType<Left>]
+            ? true
+            : false
+          : false
+        : false
+      : false
+    : false
+  : false
+
+export type CanTextuallyCoerceDbType<
+  Db extends Expression.DbType.Any,
+  Dialect extends string
+> = Db extends { readonly dialect: Dialect }
+  ? Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
+    ? CanTextuallyCoerceDbType<Base, Dialect>
+    : Db extends Expression.DbType.Enum<any, any> | Expression.DbType.Set<any, any>
+      ? true
+      : Db extends Expression.DbType.Json<any, any>
+        ? false
+        : Db extends Expression.DbType.Base<infer D extends KnownDialect, infer Kind extends string>
+          ? Kind extends keyof DialectKinds<D>
+            ? FamilyHasTextualTrait<D, BaseFamilyOf<D, Kind>> extends true
+              ? true
+              : false
+            : false
+          : false
+  : false
+
+export type CanCastDbType<
+  Source extends Expression.DbType.Any,
+  Target extends Expression.DbType.Any,
+  Dialect extends string
+> = Source extends { readonly dialect: Dialect }
+  ? Target extends { readonly dialect: Dialect }
+    ? Source extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
+      ? CanCastDbType<Base, Target, Dialect>
+      : Target extends Expression.DbType.Domain<any, infer TargetBase extends Expression.DbType.Any, any>
+        ? CanCastDbType<Source, TargetBase, Dialect>
+        : [CompareGroupOfDbType<Source>] extends [CompareGroupOfDbType<Target>]
+          ? [CompareGroupOfDbType<Target>] extends [CompareGroupOfDbType<Source>]
+            ? true
+            : false
+          : Target extends
+              | Expression.DbType.Array<any, any, any>
+              | Expression.DbType.Range<any, any, any>
+              | Expression.DbType.Multirange<any, any, any>
+              | Expression.DbType.Composite<any, any, any>
+              | Expression.DbType.Enum<any, any>
+              | Expression.DbType.Set<any, any>
+            ? true
+          : Source extends Expression.DbType.Base<infer SourceDialect extends KnownDialect, infer SourceKind extends string>
+            ? Target extends Expression.DbType.Base<infer TargetDialect extends KnownDialect, infer TargetKind extends string>
+              ? SourceDialect extends TargetDialect
+                ? SourceKind extends keyof DialectKinds<SourceDialect>
+                  ? TargetKind extends keyof DialectKinds<TargetDialect>
+                    ? BaseFamilyOf<SourceDialect, SourceKind> extends ExactKindFamily
+                      ? BaseFamilyOf<SourceDialect, TargetKind> extends "text"
+                        ? FamilyCastTargets<SourceDialect, Extract<BaseFamilyOf<SourceDialect, SourceKind>, string>> extends infer Targets extends string
+                          ? "text" extends Targets
+                            ? true
+                            : false
+                          : false
+                        : false
+                      : BaseFamilyOf<SourceDialect, TargetKind> extends FamilyCastTargets<
+                          SourceDialect,
+                          Extract<BaseFamilyOf<SourceDialect, SourceKind>, string>
+                        >
+                        ? true
+                        : false
+                    : false
+                  : false
+                : false
+              : false
+            : false
+    : false
+  : false

package/src/internal/datatypes/shape.ts

@@ -0,0 +1,72 @@
+import type {
+  BigIntString,
+  DecimalString,
+  InstantString,
+  JsonValue,
+  LocalDateString,
+  LocalDateTimeString,
+  LocalTimeString,
+  OffsetTimeString,
+  YearString
+} from "../runtime-value.js"
+
+export type RuntimeTag =
+  | "string"
+  | "number"
+  | "bigintString"
+  | "boolean"
+  | "json"
+  | "localDate"
+  | "localTime"
+  | "offsetTime"
+  | "localDateTime"
+  | "instant"
+  | "year"
+  | "decimalString"
+  | "bytes"
+  | "array"
+  | "record"
+  | "unknown"
+  | "null"
+
+export type RuntimeOfTag<Tag extends RuntimeTag> =
+  Tag extends "string" ? string :
+    Tag extends "number" ? number :
+      Tag extends "bigintString" ? BigIntString :
+        Tag extends "boolean" ? boolean :
+        Tag extends "json" ? JsonValue :
+          Tag extends "localDate" ? LocalDateString :
+            Tag extends "localTime" ? LocalTimeString :
+              Tag extends "offsetTime" ? OffsetTimeString :
+                Tag extends "localDateTime" ? LocalDateTimeString :
+                  Tag extends "instant" ? InstantString :
+                    Tag extends "year" ? YearString :
+                      Tag extends "decimalString" ? DecimalString :
+                        Tag extends "bytes" ? Uint8Array :
+                          Tag extends "array" ? ReadonlyArray<unknown> :
+                            Tag extends "record" ? Record<string, unknown> :
+                              Tag extends "null" ? null :
+                                unknown
+
+export interface DatatypeTraits {
+  readonly textual?: true
+  readonly ordered?: true
+}
+
+export interface DatatypeFamilySpec<
+  CompareGroup extends string = string,
+  CastTargets extends readonly string[] = readonly string[],
+  Traits extends DatatypeTraits = DatatypeTraits
+> {
+  readonly compareGroup: CompareGroup
+  readonly castTargets: CastTargets
+  readonly traits: Traits
+}
+
+export interface DatatypeKindSpec<
+  Family extends string = string,
+  Runtime extends RuntimeTag = RuntimeTag
+> {
+  readonly family: Family
+  readonly runtime: Runtime
+}

package/src/internal/derived-table.ts

@@ -0,0 +1,149 @@
+import { pipeArguments } from "effect/Pipeable"
+
+import * as Expression from "./expression.js"
+import * as Plan from "./plan.js"
+import {
+  type CompletePlan,
+  type CteSource,
+  type DerivedSelectionOf,
+  type DerivedSource,
+  type LateralSource,
+  type QueryPlan,
+  getAst,
+  makeExpression,
+  type SelectionOfPlan
+} from "./query.js"
+import * as ExpressionAst from "./expression-ast.js"
+import { flattenSelection } from "./projections.js"
+
+const DerivedProto = {
+  pipe(this: unknown) {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const setPath = (
+  target: Record<string, unknown>,
+  path: readonly string[],
+  value: unknown
+): void => {
+  let current = target
+  for (let index = 0; index < path.length - 1; index++) {
+    const segment = path[index]!
+    const existing = current[segment]
+    if (typeof existing === "object" && existing !== null && !Array.isArray(existing)) {
+      current = existing as Record<string, unknown>
+      continue
+    }
+    const next: Record<string, unknown> = {}
+    current[segment] = next
+    current = next
+  }
+  current[path[path.length - 1]!] = value
+}
+
+const pathAlias = (path: readonly string[]): string => path.join("__")
+
+const reboundedColumns = <
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any>,
+  Alias extends string
+>(
+  plan: PlanValue,
+  alias: Alias
+): DerivedSelectionOf<SelectionOfPlan<PlanValue>, Alias> => {
+  const ast = getAst(plan)
+  const selection = {} as Record<string, unknown>
+  for (const projection of flattenSelection(ast.select as Record<string, unknown>)) {
+    const expectedAlias = pathAlias(projection.path)
+    if (projection.alias !== expectedAlias) {
+      throw new Error(
+        `Derived subqueries currently require path-based output aliases; expected '${expectedAlias}' for path '${projection.path.join(".")}'`
+      )
+    }
+    const expression = projection.expression
+    setPath(selection, projection.path, makeExpression({
+      runtime: undefined as never,
+      dbType: expression[Expression.TypeId].dbType,
+      runtimeSchema: expression[Expression.TypeId].runtimeSchema,
+      nullability: expression[Expression.TypeId].nullability,
+      dialect: expression[Expression.TypeId].dialect,
+      aggregation: "scalar",
+      source: {
+        tableName: alias,
+        columnName: projection.alias,
+        baseTableName: alias
+      },
+      sourceNullability: "propagate" as const,
+      dependencies: {
+        [alias]: true
+      } as Record<Alias, true>
+    }, {
+      kind: "column",
+      tableName: alias,
+      columnName: projection.alias
+    } satisfies ExpressionAst.ColumnNode<Alias, string>))
+  }
+  return selection as DerivedSelectionOf<SelectionOfPlan<PlanValue>, Alias>
+}
+
+export const makeDerivedSource = <
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any>,
+  Alias extends string
+>(
+  plan: CompletePlan<PlanValue>,
+  alias: Alias
+): DerivedSource<PlanValue, Alias> => {
+  const columns = reboundedColumns(plan, alias)
+  const derived = Object.create(DerivedProto) as Record<string, unknown>
+  Object.assign(derived, columns)
+  derived.kind = "derived"
+  derived.name = alias
+  derived.baseName = alias
+  derived.dialect = plan[Plan.TypeId].dialect
+  derived.plan = plan
+  derived.required = undefined as never
+  derived.columns = columns
+  return derived as unknown as DerivedSource<PlanValue, Alias>
+}
+
+export const makeCteSource = <
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any>,
+  Alias extends string
+>(
+  plan: CompletePlan<PlanValue>,
+  alias: Alias,
+  recursive = false
+): CteSource<PlanValue, Alias> => {
+  const columns = reboundedColumns(plan, alias)
+  const cte = Object.create(DerivedProto) as Record<string, unknown>
+  Object.assign(cte, columns)
+  cte.kind = "cte"
+  cte.name = alias
+  cte.baseName = alias
+  cte.dialect = plan[Plan.TypeId].dialect
+  cte.plan = plan
+  cte.recursive = recursive
+  cte.required = undefined as never
+  cte.columns = columns
+  return cte as unknown as CteSource<PlanValue, Alias>
+}
+
+export const makeLateralSource = <
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any>,
+  Alias extends string
+>(
+  plan: PlanValue,
+  alias: Alias
+): LateralSource<PlanValue, Alias> => {
+  const columns = reboundedColumns(plan, alias)
+  const lateral = Object.create(DerivedProto) as Record<string, unknown>
+  Object.assign(lateral, columns)
+  lateral.kind = "lateral"
+  lateral.name = alias
+  lateral.baseName = alias
+  lateral.dialect = plan[Plan.TypeId].dialect
+  lateral.plan = plan
+  lateral.required = undefined as never
+  lateral.columns = columns
+  return lateral as unknown as LateralSource<PlanValue, Alias>
+}

package/src/internal/dialect.ts

@@ -0,0 +1,30 @@
+/**
+ * Mutable rendering state shared while serializing SQL for a concrete dialect.
+ *
+ * Dialect implementations append bound parameter values into `params` and
+ * refer to them positionally in the emitted SQL text.
+ */
+export interface RenderState {
+  readonly params: unknown[]
+  readonly ctes: {
+    readonly name: string
+    readonly sql: string
+    readonly recursive?: boolean
+  }[]
+  readonly cteNames: Set<string>
+}
+
+/**
+ * Minimal runtime contract for a SQL dialect.
+ *
+ * This is intentionally small for the first abstraction pass. It covers the
+ * renderer seams that are already dialect-sensitive today: identifier quoting,
+ * literal serialization, and table-reference rendering.
+ */
+export interface SqlDialect<Name extends string = string> {
+  readonly name: Name
+  quoteIdentifier(value: string): string
+  renderLiteral(value: unknown, state: RenderState): string
+  renderTableReference(tableName: string, baseTableName: string, schemaName?: string): string
+  renderConcat(values: readonly string[]): string
+}