effect-qb 0.17.0 → 0.19.0

package/src/internal/query.ts

@@ -96,7 +96,7 @@ export { union_query_capabilities } from "./query-requirements.js"
  * `Pipeable.pipe(...)` plus the metadata stored under `Expression.TypeId`.
  */
 const ExpressionProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   }
 }
@@ -108,7 +108,7 @@ const ExpressionProto = {
  * chained through `.pipe(...)`.
  */
 const PlanProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   }
 }
@@ -143,6 +143,34 @@ export interface QueryState<
 
 /** Effective SQL dialect carried by an expression. */
 export type DialectOf<Value extends Expression.Any> = Value[typeof Expression.TypeId]["dialect"]
+type ConcreteDialect<D> = D extends "standard" ? never : D
+type IsDialectUnion<Union, All = Union> = Union extends any
+  ? [All] extends [Union] ? false : true
+  : false
+export type DialectConflictError<A extends string, B extends string> = string & {
+  readonly _tag: "DialectConflict"
+  readonly left: A
+  readonly right: B
+}
+export type MergeDialect<A extends string, B extends string> =
+  [ConcreteDialect<A>, ConcreteDialect<B>] extends [never, never] ? "standard"
+    : [ConcreteDialect<A>, ConcreteDialect<B>] extends [never, infer C extends string] ? C
+      : [ConcreteDialect<A>, ConcreteDialect<B>] extends [infer C extends string, never] ? C
+        : ConcreteDialect<A> extends ConcreteDialect<B>
+          ? ConcreteDialect<B> extends ConcreteDialect<A>
+            ? A
+            : DialectConflictError<A, B>
+          : DialectConflictError<A, B>
+
+/** Collapses the portable standard tag out of a dialect union. */
+export type NormalizeDialect<Dialect extends string> =
+  [Dialect] extends [never]
+    ? never
+    : [Exclude<Dialect, "standard">] extends [never]
+      ? "standard"
+      : IsDialectUnion<Exclude<Dialect, "standard">> extends true
+        ? DialectConflictError<Exclude<Dialect, "standard">, Exclude<Dialect, "standard">>
+        : Exclude<Dialect, "standard">
 /** Source dependency union carried by an expression. */
 export type DependenciesOf<Value extends Expression.Any> = Expression.DependenciesOf<Value>
 /** Aggregation kind carried by an expression. */
@@ -464,15 +492,17 @@ export type ExtractRequired<Selection> = Selection extends Expression.Any
       }[keyof Selection]
     : never
 
-/** Walks a selection tree and unions the dialects referenced by its leaves. */
-export type ExtractDialect<Selection> = Selection extends Expression.Any
+type ExtractDialectRaw<Selection> = Selection extends Expression.Any
   ? DialectOf<Selection>
   : Selection extends Record<string, any>
     ? {
-        [K in keyof Selection]: ExtractDialect<Selection[K]>
+        [K in keyof Selection]: ExtractDialectRaw<Selection[K]>
       }[keyof Selection]
     : never
 
+/** Walks a selection tree and extracts the effective dialects referenced by its leaves. */
+export type ExtractDialect<Selection> = NormalizeDialect<Extract<ExtractDialectRaw<Selection>, string>>
+
 /**
  * Minimal table-like shape required by `from(...)` and joins.
  *
@@ -1005,8 +1035,7 @@ export type UpdateInputOfTarget<Target extends MutationTargetInput> =
         }>
       : never
 
-/** Extracts the effective dialect from a source. */
-export type SourceDialectOf<Source extends SourceLike> =
+type SourceDialectOfRaw<Source extends SourceLike> =
   Source extends TableLike<any, infer Dialect> ? Dialect :
     Source extends { readonly kind: "derived"; readonly plan: infer PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any> } ? PlanDialectOf<PlanValue> :
       Source extends { readonly kind: "cte"; readonly plan: infer PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any> } ? PlanDialectOf<PlanValue> :
@@ -1014,6 +1043,9 @@ export type SourceDialectOf<Source extends SourceLike> =
           Source extends { readonly dialect: infer Dialect extends string } ? Dialect :
       never
 
+/** Extracts the effective dialect from a source. */
+export type SourceDialectOf<Source extends SourceLike> = NormalizeDialect<SourceDialectOfRaw<Source>>
+
 /** Extracts the base table name from a source. */
 export type SourceBaseNameOf<Source extends SourceLike> =
   Source extends TableLike<any, any> ? Source[typeof Table.TypeId]["baseName"] :
@@ -1148,6 +1180,21 @@ type DerivedProjectionIssues<Selection> =
     : | DerivedProjectionDuplicateAliases<Selection>
       | DerivedProjectionAliasMismatches<Selection>
 
+export type SelectionProjectionDuplicateAliases<Selection> =
+  IsBroadSelection<Selection> extends true
+    ? never
+    : DuplicateProjectionAliases<SelectionProjectionEntries<Selection>>
+
+export type SelectionProjectionAliasCollisionError<Selection> = Selection & {
+  readonly __effect_qb_error__: "effect-qb: projection aliases must be unique"
+  readonly __effect_qb_duplicate_projection_aliases__: SelectionProjectionDuplicateAliases<Selection>
+}
+
+export type SelectionProjectionAliasCollisionConstraint<Selection> =
+  [SelectionProjectionDuplicateAliases<Selection>] extends [never]
+    ? unknown
+    : SelectionProjectionAliasCollisionError<Selection>
+
 export type DerivedSourceProjectionCompatibilityError<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
 > = PlanValue & {
@@ -1254,7 +1301,7 @@ export type AvailableOfPlan<
 /** Extracts the effective dialect carried by a query plan. */
 export type PlanDialectOf<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
-> = QueryPlanParts<PlanValue>["dialect"]
+> = NormalizeDialect<QueryPlanParts<PlanValue>["dialect"]>
 /** Extracts the grouped-source phantom carried by a query plan. */
 export type GroupedOfPlan<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
@@ -1465,7 +1512,7 @@ export type MergeNullabilityTuple<
 /** Dialect union across a tuple of expressions. */
 export type TupleDialect<
   Values extends readonly Expression.Any[]
-> = Values[number] extends never ? never : DialectOf<Values[number]>
+> = Values[number] extends never ? never : NormalizeDialect<DialectOf<Values[number]>>
 
 /** Converts a union into an intersection. */
 type UnionToIntersection<Union> = (
@@ -2124,7 +2171,7 @@ type DialectCompatibilityError<
   EngineDialect extends string
 > = PlanValue & {
   readonly __effect_qb_error__: "effect-qb: plan dialect is not compatible with the target renderer or executor"
-  readonly __effect_qb_plan_dialect__: PlanValue[typeof RowSet.TypeId]["dialect"]
+  readonly __effect_qb_plan_dialect__: PlanDialectOf<PlanValue>
   readonly __effect_qb_target_dialect__: EngineDialect
   readonly __effect_qb_hint__: "Use the matching dialect module or renderer/executor"
 }
@@ -2175,7 +2222,7 @@ type IsDialectCompatible<
   EngineDialect extends string
 > = [PlanDialect] extends [never]
   ? true
-  : Exclude<PlanDialect, EngineDialect> extends never
+  : Exclude<PlanDialect, EngineDialect | "standard"> extends never
     ? true
     : false
 
@@ -2183,7 +2230,7 @@ type IsDialectCompatible<
 export type DialectCompatiblePlan<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   EngineDialect extends string
-> = IsDialectCompatible<PlanValue[typeof RowSet.TypeId]["dialect"], EngineDialect> extends true
+> = IsDialectCompatible<PlanDialectOf<PlanValue>, EngineDialect> extends true
   ? CompletePlan<PlanValue>
   : DialectCompatibilityError<PlanValue, EngineDialect>
 
@@ -2201,7 +2248,7 @@ type NestedPlanStatementError<
 export type DialectCompatibleNestedPlan<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   EngineDialect extends string
-> = IsDialectCompatible<PlanValue[typeof RowSet.TypeId]["dialect"], EngineDialect> extends true
+> = IsDialectCompatible<PlanDialectOf<PlanValue>, EngineDialect> extends true
   ? StatementOfPlan<PlanValue> extends SelectLikeStatement
     ? AggregationCompatiblePlan<PlanValue>
     : NestedPlanStatementError<PlanValue>
@@ -2427,7 +2474,7 @@ export const makeExpression = <
   Object.defineProperty(expression, "pipe", {
     configurable: true,
     writable: true,
-    value: function(this: unknown) {
+    value: function(this: Pipeable) {
       return pipeArguments(expression, arguments)
     }
   })
@@ -2477,7 +2524,7 @@ export const makePlan = <
   Object.defineProperty(plan, "pipe", {
     configurable: true,
     writable: true,
-    value: function(this: unknown) {
+    value: function(this: Pipeable) {
       return pipeArguments(plan, arguments)
     }
   })
@@ -2536,16 +2583,8 @@ export const extractRequiredRuntime = (selection: SelectionShape): readonly stri
 
 /** Extracts the single top-level expression from a scalar subquery selection. */
 export const extractSingleSelectedExpressionRuntime = (selection: SelectionShape): Expression.Any => {
-  const keys = Object.keys(selection)
-  if (keys.length !== 1) {
-    throw new Error("scalar subqueries must select exactly one top-level expression")
-  }
-  const record = selection as Record<string, unknown>
-  const value = record[keys[0]!]
-  if (value === null || typeof value !== "object" || !(Expression.TypeId in (value as object))) {
-    throw new Error("scalar subqueries must select a scalar expression")
-  }
-  return value as unknown as Expression.Any
+  const record = selection as Record<string, Expression.Any>
+  return record[Object.keys(record)[0]!]!
 }
 
 /** Converts the plan's runtime `required` metadata into a mutable string list. */

package/src/internal/renderer.ts

@@ -1,7 +1,6 @@
 import * as Query from "./query.js"
-import type * as Expression from "./scalar.js"
+import * as Expression from "./scalar.js"
 import { flattenSelection, type Projection, validateProjections } from "./projections.js"
-import * as Plan from "./row-set.js"
 
 /** Symbol used to attach rendered-query phantom row metadata. */
 export const TypeId: unique symbol = Symbol.for("effect-qb/Renderer")
@@ -38,8 +37,7 @@ export type RowOf<Value extends RenderedQuery<any, any>> = Value[typeof TypeId][
  *
  * Renderers only accept complete, dialect-compatible plans. The returned
  * `RenderedQuery` keeps the canonical `Query.ResultRow<...>` type attached for
- * downstream executor layers, and the built-in renderer also performs a
- * matching runtime aggregate-shape validation.
+ * downstream executor layers.
  */
 export interface Renderer<Dialect extends string = string> {
   readonly dialect: Dialect
@@ -91,24 +89,38 @@ export function make<Dialect extends string>(
   dialect: Dialect,
   render: CustomRender<Dialect>
 ): Renderer<Dialect> {
+  return makeRenderer(dialect, render, true)
+}
+
+/** Internal renderer factory for built-in renderers that derive projections from typed plans. */
+export function makeTrusted<Dialect extends string>(
+  dialect: Dialect,
+  render: CustomRender<Dialect>
+): Renderer<Dialect>
+export function makeTrusted<Dialect extends string>(
+  dialect: Dialect,
+  render: CustomRender<Dialect>
+): Renderer<Dialect> {
+  return makeRenderer(dialect, render, false)
+}
+
+const makeRenderer = <Dialect extends string>(
+  dialect: Dialect,
+  render: CustomRender<Dialect>,
+  validate: boolean
+): Renderer<Dialect> => {
   if (typeof render !== "function") {
     throw new Error(`Renderer.make requires an explicit render implementation for dialect: ${dialect}`)
   }
   return {
     dialect,
     render(plan) {
-      const required = Query.currentRequiredList(plan[Plan.TypeId].required)
-      if (required.length > 0) {
-        throw new Error(`query references sources that are not yet in scope: ${required.join(", ")}`)
-      }
-      const planDialect = plan[Plan.TypeId].dialect
-      if (planDialect !== dialect) {
-        throw new Error("effect-qb: plan dialect is not compatible with the target renderer or executor")
-      }
       const rendered = render(plan)
       const projections = rendered.projections ?? []
-      validateProjections(projections)
-      validateProjectionPathsMatchSelection(plan as Query.Plan.Any, projections)
+      if (validate) {
+        validateProjections(projections)
+        validateProjectionPathsMatchSelection(plan as Query.Plan.Any, projections)
+      }
       return {
         sql: rendered.sql,
         params: rendered.params ?? [],

package/src/internal/runtime/normalize.ts

@@ -23,6 +23,13 @@ const isPlainRecord = (value: unknown): value is Record<string, unknown> => {
 
 const pad = (value: number, width = 2): string => value.toString().padStart(width, "0")
 
+const validDate = (value: Date): Date => {
+  if (Number.isNaN(value.getTime())) {
+    throw new Error("Expected a valid Date value")
+  }
+  return value
+}
+
 const formatLocalDate = (value: Date): string =>
   `${pad(value.getUTCFullYear(), 4)}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`
 
@@ -125,7 +132,7 @@ const normalizeDecimalString = (value: unknown): string => {
 
 const normalizeLocalDate = (value: unknown): string => {
   if (value instanceof Date) {
-    return formatLocalDate(value)
+    return formatLocalDate(validDate(value))
   }
   const raw = expectString(value, "local date").trim()
   if (isValidLocalDateString(raw)) {
@@ -143,7 +150,7 @@ const normalizeLocalDate = (value: unknown): string => {
 
 const normalizeLocalTime = (value: unknown): string => {
   if (value instanceof Date) {
-    return formatLocalTime(value)
+    return formatLocalTime(validDate(value))
   }
   const raw = expectString(value, "local time").trim()
   if (isValidLocalTimeString(raw)) {
@@ -154,7 +161,7 @@ const normalizeLocalTime = (value: unknown): string => {
 
 const normalizeOffsetTime = (value: unknown): string => {
   if (value instanceof Date) {
-    return `${formatLocalTime(value)}Z`
+    return `${formatLocalTime(validDate(value))}Z`
   }
   const raw = expectString(value, "offset time").trim()
   if (isValidOffsetTimeString(raw)) {
@@ -165,7 +172,7 @@ const normalizeOffsetTime = (value: unknown): string => {
 
 const normalizeLocalDateTime = (value: unknown): string => {
   if (value instanceof Date) {
-    return formatLocalDateTime(value)
+    return formatLocalDateTime(validDate(value))
   }
   const raw = expectString(value, "local datetime").trim()
   const canonicalLocalDateTime = raw.replace(" ", "T")
@@ -184,7 +191,7 @@ const normalizeLocalDateTime = (value: unknown): string => {
 
 const normalizeInstant = (value: unknown): string => {
   if (value instanceof Date) {
-    return value.toISOString()
+    return validDate(value).toISOString()
   }
   const raw = expectString(value, "instant").trim()
   if (!/[zZ]|[+-]\d{2}:\d{2}$/.test(raw)) {

package/src/internal/scalar.ts

@@ -143,7 +143,12 @@ export interface DriverValueMapping {
   readonly jsonSelectSql?: (sql: string, dbType: DbType.Any) => string
 }
 
-export type DriverValueMappings = Readonly<Record<string, DriverValueMapping | undefined>>
+export type DriverValueMappings = Readonly<Partial<Record<string, DriverValueMapping>>>
+
+export type DriverValueMappingsFor<
+  Kind extends string,
+  Family extends string
+> = Readonly<Partial<Record<Kind | Family | RuntimeTag, DriverValueMapping>>>
 
 /** Canonical static metadata stored on an expression. */
 export interface State<

package/src/internal/schema-derivation.d.ts

@@ -1,64 +1,7 @@
-import * as VariantSchema from "@effect/experimental/VariantSchema";
 import type * as Brand from "effect/Brand";
 import * as Schema from "effect/Schema";
 import { type AnyColumnDefinition, type HasDefault, type InsertType, type IsGenerated, type IsNullable, type SelectType, type UpdateType } from "./column-state.js";
-/** Variant-schema helper used to derive select / insert / update schemas. */
-export declare const TableSchema: {
-    readonly Struct: <const A extends VariantSchema.Struct.Fields>(fields: A & VariantSchema.Struct.Validate<A, "insert" | "select" | "update">) => VariantSchema.Struct<A>;
-    readonly Field: <const A extends VariantSchema.Field.ConfigWithKeys<"insert" | "select" | "update">>(config: A & { readonly [K in Exclude<keyof A, "insert" | "select" | "update">]: never; }) => VariantSchema.Field<A>;
-    readonly FieldOnly: <const Keys extends readonly ("insert" | "select" | "update")[]>(...keys: Keys) => <S extends Schema.Schema.All | Schema.PropertySignature.All<PropertyKey>>(schema: S) => VariantSchema.Field<{ readonly [K in Keys[number]]: S; }>;
-    readonly FieldExcept: <const Keys extends readonly ("insert" | "select" | "update")[]>(...keys: Keys) => <S extends Schema.Schema.All | Schema.PropertySignature.All<PropertyKey>>(schema: S) => VariantSchema.Field<{ readonly [K in Exclude<"insert", Keys[number]> | Exclude<"select", Keys[number]> | Exclude<"update", Keys[number]>]: S; }>;
-    readonly fieldEvolve: {
-        <Self extends VariantSchema.Field<any> | VariantSchema.Field.ValueAny, const Mapping extends Self extends VariantSchema.Field<infer S extends VariantSchema.Field.Config> ? { readonly [K in keyof S]?: ((variant: S[K]) => VariantSchema.Field.ValueAny) | undefined; } : {
-            readonly insert?: ((variant: Self) => VariantSchema.Field.ValueAny) | undefined;
-            readonly select?: ((variant: Self) => VariantSchema.Field.ValueAny) | undefined;
-            readonly update?: ((variant: Self) => VariantSchema.Field.ValueAny) | undefined;
-        }>(f: Mapping): (self: Self) => VariantSchema.Field<Self extends VariantSchema.Field<infer S_1 extends VariantSchema.Field.Config> ? { readonly [K in keyof S_1]: K extends keyof Mapping ? Mapping[K] extends (arg: any) => any ? ReturnType<Mapping[K]> : S_1[K] : S_1[K]; } : {
-            readonly insert: "insert" extends infer T ? T extends "insert" ? T extends keyof Mapping ? Mapping[T] extends (arg: any) => any ? ReturnType<Mapping[T]> : Self : Self : never : never;
-            readonly select: "select" extends infer T_1 ? T_1 extends "select" ? T_1 extends keyof Mapping ? Mapping[T_1] extends (arg: any) => any ? ReturnType<Mapping[T_1]> : Self : Self : never : never;
-            readonly update: "update" extends infer T_2 ? T_2 extends "update" ? T_2 extends keyof Mapping ? Mapping[T_2] extends (arg: any) => any ? ReturnType<Mapping[T_2]> : Self : Self : never : never;
-        }>;
-        <Self extends VariantSchema.Field<any> | VariantSchema.Field.ValueAny, const Mapping_1 extends Self extends VariantSchema.Field<infer S extends VariantSchema.Field.Config> ? { readonly [K in keyof S]?: ((variant: S[K]) => VariantSchema.Field.ValueAny) | undefined; } : {
-            readonly insert?: ((variant: Self) => VariantSchema.Field.ValueAny) | undefined;
-            readonly select?: ((variant: Self) => VariantSchema.Field.ValueAny) | undefined;
-            readonly update?: ((variant: Self) => VariantSchema.Field.ValueAny) | undefined;
-        }>(self: Self, f: Mapping_1): VariantSchema.Field<Self extends VariantSchema.Field<infer S_1 extends VariantSchema.Field.Config> ? { readonly [K in keyof S_1]: K extends keyof Mapping_1 ? Mapping_1[K] extends (arg: any) => any ? ReturnType<Mapping_1[K]> : S_1[K] : S_1[K]; } : {
-            readonly insert: "insert" extends infer T ? T extends "insert" ? T extends keyof Mapping_1 ? Mapping_1[T] extends (arg: any) => any ? ReturnType<Mapping_1[T]> : Self : Self : never : never;
-            readonly select: "select" extends infer T_1 ? T_1 extends "select" ? T_1 extends keyof Mapping_1 ? Mapping_1[T_1] extends (arg: any) => any ? ReturnType<Mapping_1[T_1]> : Self : Self : never : never;
-            readonly update: "update" extends infer T_2 ? T_2 extends "update" ? T_2 extends keyof Mapping_1 ? Mapping_1[T_2] extends (arg: any) => any ? ReturnType<Mapping_1[T_2]> : Self : Self : never : never;
-        }>;
-    };
-    readonly fieldFromKey: {
-        <Self extends VariantSchema.Field<any> | VariantSchema.Field.ValueAny, const Mapping_2 extends Self extends VariantSchema.Field<infer S extends VariantSchema.Field.Config> ? { readonly [K in keyof S]?: string | undefined; } : {
-            readonly insert?: string | undefined;
-            readonly select?: string | undefined;
-            readonly update?: string | undefined;
-        }>(mapping: Mapping_2): (self: Self) => VariantSchema.Field<Self extends VariantSchema.Field<infer S_1 extends VariantSchema.Field.Config> ? { readonly [K in keyof S_1]: K extends keyof Mapping_2 ? Mapping_2[K] extends string ? VariantSchema.fromKey.Rename<S_1[K], Mapping_2[K]> : S_1[K] : S_1[K]; } : {
-            readonly insert: "insert" extends infer T ? T extends "insert" ? T extends keyof Mapping_2 ? Mapping_2[T] extends string ? VariantSchema.fromKey.Rename<Self, Mapping_2[T]> : Self : Self : never : never;
-            readonly select: "select" extends infer T_1 ? T_1 extends "select" ? T_1 extends keyof Mapping_2 ? Mapping_2[T_1] extends string ? VariantSchema.fromKey.Rename<Self, Mapping_2[T_1]> : Self : Self : never : never;
-            readonly update: "update" extends infer T_2 ? T_2 extends "update" ? T_2 extends keyof Mapping_2 ? Mapping_2[T_2] extends string ? VariantSchema.fromKey.Rename<Self, Mapping_2[T_2]> : Self : Self : never : never;
-        }>;
-        <Self extends VariantSchema.Field<any> | VariantSchema.Field.ValueAny, const Mapping_3 extends Self extends VariantSchema.Field<infer S extends VariantSchema.Field.Config> ? { readonly [K in keyof S]?: string | undefined; } : {
-            readonly insert?: string | undefined;
-            readonly select?: string | undefined;
-            readonly update?: string | undefined;
-        }>(self: Self, mapping: Mapping_3): VariantSchema.Field<Self extends VariantSchema.Field<infer S_1 extends VariantSchema.Field.Config> ? { readonly [K in keyof S_1]: K extends keyof Mapping_3 ? Mapping_3[K] extends string ? VariantSchema.fromKey.Rename<S_1[K], Mapping_3[K]> : S_1[K] : S_1[K]; } : {
-            readonly insert: "insert" extends infer T ? T extends "insert" ? T extends keyof Mapping_3 ? Mapping_3[T] extends string ? VariantSchema.fromKey.Rename<Self, Mapping_3[T]> : Self : Self : never : never;
-            readonly select: "select" extends infer T_1 ? T_1 extends "select" ? T_1 extends keyof Mapping_3 ? Mapping_3[T_1] extends string ? VariantSchema.fromKey.Rename<Self, Mapping_3[T_1]> : Self : Self : never : never;
-            readonly update: "update" extends infer T_2 ? T_2 extends "update" ? T_2 extends keyof Mapping_3 ? Mapping_3[T_2] extends string ? VariantSchema.fromKey.Rename<Self, Mapping_3[T_2]> : Self : Self : never : never;
-        }>;
-    };
-    readonly Class: <Self = never>(identifier: string) => <const Fields extends VariantSchema.Struct.Fields>(fields: Fields & VariantSchema.Struct.Validate<Fields, "insert" | "select" | "update">, annotations?: Schema.Annotations.Schema<Self, readonly []> | undefined) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Class<Self>()({ ... })`" : VariantSchema.Class<Self, Fields, VariantSchema.ExtractFields<"select", Fields, true>, Schema.Struct.Type<VariantSchema.ExtractFields<"select", Fields, true>>, Schema.Struct.Encoded<VariantSchema.ExtractFields<"select", Fields, true>>, Schema.Schema.Context<VariantSchema.ExtractFields<"select", Fields, true>[keyof VariantSchema.ExtractFields<"select", Fields, true>]>, Schema.Struct.Constructor<VariantSchema.ExtractFields<"select", Fields, true>>> & {
-        readonly insert: Schema.Struct<VariantSchema.ExtractFields<"insert", Fields, false> extends infer T ? { [K in keyof T]: T[K]; } : never>;
-        readonly select: Schema.Struct<VariantSchema.ExtractFields<"select", Fields, false> extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never>;
-        readonly update: Schema.Struct<VariantSchema.ExtractFields<"update", Fields, false> extends infer T_2 ? { [K in keyof T_2]: T_2[K]; } : never>;
-    };
-    readonly Union: <const Members extends readonly VariantSchema.Struct<any>[]>(...members: Members) => VariantSchema.Union<Members> & VariantSchema.Union.Variants<Members, "insert" | "select" | "update">;
-    readonly extract: {
-        <V extends "insert" | "select" | "update">(variant: V): <A extends VariantSchema.Struct<any>>(self: A) => VariantSchema.Extract<V, A, V extends "select" ? true : false>;
-        <V extends "insert" | "select" | "update", A extends VariantSchema.Struct<any>>(self: A, variant: V): VariantSchema.Extract<V, A, V extends "select" ? true : false>;
-    };
-};
+export type TableSchemaVariant = "select" | "insert" | "update";
 /** Normalized field map used by table definitions. */
 export type TableFieldMap = Record<string, AnyColumnDefinition>;
 type GeneratedKeys<Fields extends TableFieldMap> = {
@@ -91,15 +34,23 @@ export type InsertRow<TableName extends string, Fields extends TableFieldMap> =
 export type UpdateRow<TableName extends string, Fields extends TableFieldMap, PrimaryKey extends keyof Fields> = Simplify<Partial<{
     [K in UpdateKeys<Fields, PrimaryKey>]: BrandedUpdateType<Fields[K], TableName, Extract<K, string>>;
 }>>;
+type SchemaOfVariant<Variant extends TableSchemaVariant, TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string> = Variant extends "select" ? Schema.Schema<SelectRow<TableName, Fields>> : Variant extends "insert" ? Schema.Schema<InsertRow<TableName, Fields>> : Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>;
+export declare const deriveSchema: <Variant extends TableSchemaVariant, TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(variant: Variant, tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => SchemaOfVariant<Variant, TableName, Fields, PrimaryKeyColumns>;
+export declare const deriveSelectSchema: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => Schema.Schema<SelectRow<TableName, Fields>>;
+export declare const deriveInsertSchema: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => Schema.Schema<InsertRow<TableName, Fields>>;
+export declare const deriveUpdateSchema: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>;
 /**
  * Derives the `select`, `insert`, and `update` schemas for a table.
  *
  * This is the central place where the column capability flags are turned into
  * real runtime schemas.
+ *
+ * @deprecated Prefer `deriveSelectSchema`, `deriveInsertSchema`, and
+ * `deriveUpdateSchema` so individual variants are derived lazily.
  */
 export declare const deriveSchemas: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => {
-    readonly select: Schema.Schema<{ [K in keyof { [K in keyof Fields]: BrandedSelectType<Fields[K], TableName, Extract<K, string>>; }]: { [K in keyof Fields]: BrandedSelectType<Fields[K], TableName, Extract<K, string>>; }[K]; }, { [K in keyof { [K in keyof Fields]: BrandedSelectType<Fields[K], TableName, Extract<K, string>>; }]: { [K in keyof Fields]: BrandedSelectType<Fields[K], TableName, Extract<K, string>>; }[K]; }, never>;
-    readonly insert: Schema.Schema<{ [K in Exclude<keyof Fields, GeneratedKeys<Fields> | OptionalInsertKeys<Fields>>]: BrandedInsertType<Fields[K], TableName, Extract<K, string>>; } & { [K in OptionalInsertKeys<Fields>]?: BrandedInsertType<Fields[K], TableName, Extract<K, string>> | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never, { [K in Exclude<keyof Fields, GeneratedKeys<Fields> | OptionalInsertKeys<Fields>>]: BrandedInsertType<Fields[K], TableName, Extract<K, string>>; } & { [K in OptionalInsertKeys<Fields>]?: BrandedInsertType<Fields[K], TableName, Extract<K, string>> | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never, never>;
-    readonly update: Schema.Schema<Partial<{ [K in Exclude<keyof Fields, PrimaryKeyColumns | GeneratedKeys<Fields>>]: BrandedUpdateType<Fields[K], TableName, Extract<K, string>>; }> extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never, Partial<{ [K in Exclude<keyof Fields, PrimaryKeyColumns | GeneratedKeys<Fields>>]: BrandedUpdateType<Fields[K], TableName, Extract<K, string>>; }> extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never, never>;
+    readonly select: Schema.Schema<SelectRow<TableName, Fields>>;
+    readonly insert: Schema.Schema<InsertRow<TableName, Fields>>;
+    readonly update: Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>;
 };
 export {};

package/src/internal/schema-derivation.ts

@@ -1,4 +1,3 @@
-import * as VariantSchema from "@effect/experimental/VariantSchema"
 import type * as Brand from "effect/Brand"
 import * as Schema from "effect/Schema"
 
@@ -12,13 +11,7 @@ import {
   type UpdateType
 } from "./column-state.js"
 
-/** Variant-schema helper used to derive select / insert / update schemas. */
-export const TableSchema = VariantSchema.make({
-  variants: ["select", "insert", "update"] as const,
-  defaultVariant: "select"
-})
-
-type Variants = "select" | "insert" | "update"
+export type TableSchemaVariant = "select" | "insert" | "update"
 
 /** Normalized field map used by table definitions. */
 export type TableFieldMap = Record<string, AnyColumnDefinition>
@@ -153,11 +146,95 @@ const updateSchema = (
   return Schema.optional(base)
 }
 
+type SchemaOfVariant<
+  Variant extends TableSchemaVariant,
+  TableName extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+> = Variant extends "select" ? Schema.Schema<SelectRow<TableName, Fields>>
+  : Variant extends "insert" ? Schema.Schema<InsertRow<TableName, Fields>>
+  : Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>
+
+const fieldSchemaForVariant = (
+  variant: TableSchemaVariant,
+  column: AnyColumnDefinition,
+  tableName: string,
+  columnName: string,
+  primaryKeySet: ReadonlySet<string>
+): any | undefined => {
+  switch (variant) {
+    case "select":
+      return selectSchema(column, tableName, columnName)
+    case "insert":
+      return insertSchema(column, tableName, columnName)
+    case "update":
+      return updateSchema(column, tableName, columnName, primaryKeySet.has(columnName))
+  }
+}
+
+export const deriveSchema = <
+  Variant extends TableSchemaVariant,
+  TableName extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  variant: Variant,
+  tableName: TableName,
+  fields: Fields,
+  primaryKeyColumns: readonly PrimaryKeyColumns[]
+): SchemaOfVariant<Variant, TableName, Fields, PrimaryKeyColumns> => {
+  const primaryKeySet = new Set<string>(primaryKeyColumns)
+  const structFields: Record<string, any> = {}
+  for (const [key, column] of Object.entries(fields)) {
+    const schema = fieldSchemaForVariant(variant, column, tableName, key, primaryKeySet)
+    if (schema !== undefined) {
+      structFields[key] = schema
+    }
+  }
+  return Schema.Struct(structFields) as unknown as SchemaOfVariant<Variant, TableName, Fields, PrimaryKeyColumns>
+}
+
+export const deriveSelectSchema = <
+  TableName extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  tableName: TableName,
+  fields: Fields,
+  primaryKeyColumns: readonly PrimaryKeyColumns[]
+): Schema.Schema<SelectRow<TableName, Fields>> =>
+  deriveSchema("select", tableName, fields, primaryKeyColumns)
+
+export const deriveInsertSchema = <
+  TableName extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  tableName: TableName,
+  fields: Fields,
+  primaryKeyColumns: readonly PrimaryKeyColumns[]
+): Schema.Schema<InsertRow<TableName, Fields>> =>
+  deriveSchema("insert", tableName, fields, primaryKeyColumns)
+
+export const deriveUpdateSchema = <
+  TableName extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  tableName: TableName,
+  fields: Fields,
+  primaryKeyColumns: readonly PrimaryKeyColumns[]
+): Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>> =>
+  deriveSchema("update", tableName, fields, primaryKeyColumns)
+
 /**
  * Derives the `select`, `insert`, and `update` schemas for a table.
  *
  * This is the central place where the column capability flags are turned into
  * real runtime schemas.
+ *
+ * @deprecated Prefer `deriveSelectSchema`, `deriveInsertSchema`, and
+ * `deriveUpdateSchema` so individual variants are derived lazily.
  */
 export const deriveSchemas = <
   TableName extends string,
@@ -171,33 +248,8 @@ export const deriveSchemas = <
   readonly select: Schema.Schema<SelectRow<TableName, Fields>>
   readonly insert: Schema.Schema<InsertRow<TableName, Fields>>
   readonly update: Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>
-} => {
-  const primaryKeySet = new Set<string>(primaryKeyColumns)
-  const variants: Record<string, VariantSchema.Field<any>> = {}
-  for (const [key, column] of Object.entries(fields)) {
-    const config: Record<Variants, any> = {
-      select: selectSchema(column, tableName, key),
-      insert: undefined,
-      update: undefined
-    }
-    const insert = insertSchema(column, tableName, key)
-    const update = updateSchema(column, tableName, key, primaryKeySet.has(key))
-    if (insert !== undefined) {
-      config.insert = insert
-    } else {
-      delete config.insert
-    }
-    if (update !== undefined) {
-      config.update = update
-    } else {
-      delete config.update
-    }
-    variants[key] = TableSchema.Field(config)
-  }
-  const struct = TableSchema.Struct(variants as any)
-  return {
-    select: TableSchema.extract(struct, "select") as unknown as Schema.Schema<SelectRow<TableName, Fields>>,
-    insert: TableSchema.extract(struct, "insert") as unknown as Schema.Schema<InsertRow<TableName, Fields>>,
-    update: TableSchema.extract(struct, "update") as unknown as Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>
-  }
-}
+} => ({
+  select: deriveSelectSchema(tableName, fields, primaryKeyColumns),
+  insert: deriveInsertSchema(tableName, fields, primaryKeyColumns),
+  update: deriveUpdateSchema(tableName, fields, primaryKeyColumns)
+})

package/src/internal/schema-expression.ts

@@ -6,7 +6,7 @@ export const TypeId: unique symbol = Symbol.for("effect-qb/SchemaExpression")
 export type TypeId = typeof TypeId
 
 const SchemaExpressionProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   }
 }
@@ -15,7 +15,7 @@ const attachPipe = <Value extends object>(value: Value): Value => {
   Object.defineProperty(value, "pipe", {
     configurable: true,
     writable: true,
-    value: function(this: unknown) {
+    value: function(this: Value) {
       return pipeArguments(value, arguments)
     }
   })

package/src/internal/sql-expression-renderer.ts

@@ -0,0 +1,19 @@
+import type { RenderedAst, RenderState, SqlDialect } from "./dialect.js"
+import type * as Expression from "./scalar.js"
+import type * as QueryAst from "./query-ast.js"
+
+export const renderQueryAst = (
+  ast: QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
+  state: RenderState,
+  dialect: SqlDialect
+): RenderedAst => {
+  return dialect.renderQueryAst(ast, state, dialect)
+}
+
+export const renderExpression = (
+  expression: Expression.Any,
+  state: RenderState,
+  dialect: SqlDialect
+): string => {
+  return dialect.renderExpression(expression, state, dialect)
+}