npm - effect-qb - Versions diffs - 0.16.0 → 0.17.0 - Mend

effect-qb 0.16.0 → 0.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (75) hide show

package/dist/mysql.js +1661 -591
package/dist/postgres/metadata.js +1930 -135
package/dist/postgres.js +7808 -6718
package/dist/sqlite.js +8360 -0
package/package.json +6 -1
package/src/internal/derived-table.ts +29 -3
package/src/internal/dialect.ts +2 -0
package/src/internal/dsl-mutation-runtime.ts +173 -4
package/src/internal/dsl-plan-runtime.ts +165 -20
package/src/internal/dsl-query-runtime.ts +60 -6
package/src/internal/dsl-transaction-ddl-runtime.ts +72 -2
package/src/internal/executor.ts +47 -9
package/src/internal/expression-ast.ts +3 -2
package/src/internal/grouping-key.ts +141 -1
package/src/internal/implication-runtime.ts +2 -1
package/src/internal/json/types.ts +155 -40
package/src/internal/predicate/context.ts +14 -1
package/src/internal/predicate/key.ts +19 -2
package/src/internal/predicate/runtime.ts +27 -3
package/src/internal/query.ts +252 -30
package/src/internal/renderer.ts +35 -2
package/src/internal/runtime/driver-value-mapping.ts +58 -0
package/src/internal/runtime/normalize.ts +62 -38
package/src/internal/runtime/schema.ts +5 -3
package/src/internal/runtime/value.ts +153 -30
package/src/internal/table-options.ts +108 -1
package/src/internal/table.ts +87 -29
package/src/mysql/column.ts +18 -2
package/src/mysql/datatypes/index.ts +21 -0
package/src/mysql/errors/catalog.ts +5 -5
package/src/mysql/errors/normalize.ts +2 -2
package/src/mysql/internal/dsl.ts +736 -218
package/src/mysql/internal/renderer.ts +2 -1
package/src/mysql/internal/sql-expression-renderer.ts +486 -130
package/src/mysql/query.ts +9 -2
package/src/mysql/table.ts +38 -12
package/src/postgres/column.ts +4 -2
package/src/postgres/errors/normalize.ts +2 -2
package/src/postgres/executor.ts +48 -5
package/src/postgres/function/core.ts +19 -1
package/src/postgres/internal/dsl.ts +683 -240
package/src/postgres/internal/renderer.ts +2 -1
package/src/postgres/internal/schema-ddl.ts +2 -1
package/src/postgres/internal/schema-model.ts +6 -3
package/src/postgres/internal/sql-expression-renderer.ts +420 -91
package/src/postgres/json.ts +57 -17
package/src/postgres/query.ts +9 -2
package/src/postgres/schema-management.ts +91 -4
package/src/postgres/schema.ts +1 -1
package/src/postgres/table.ts +189 -53
package/src/sqlite/column.ts +128 -0
package/src/sqlite/datatypes/index.ts +79 -0
package/src/sqlite/datatypes/spec.ts +98 -0
package/src/sqlite/errors/catalog.ts +103 -0
package/src/sqlite/errors/fields.ts +19 -0
package/src/sqlite/errors/index.ts +19 -0
package/src/sqlite/errors/normalize.ts +229 -0
package/src/sqlite/errors/requirements.ts +71 -0
package/src/sqlite/errors/types.ts +29 -0
package/src/sqlite/executor.ts +227 -0
package/src/sqlite/function/aggregate.ts +2 -0
package/src/sqlite/function/core.ts +2 -0
package/src/sqlite/function/index.ts +19 -0
package/src/sqlite/function/string.ts +2 -0
package/src/sqlite/function/temporal.ts +100 -0
package/src/sqlite/function/window.ts +2 -0
package/src/sqlite/internal/dialect.ts +37 -0
package/src/sqlite/internal/dsl.ts +6926 -0
package/src/sqlite/internal/renderer.ts +47 -0
package/src/sqlite/internal/sql-expression-renderer.ts +1821 -0
package/src/sqlite/json.ts +2 -0
package/src/sqlite/query.ts +196 -0
package/src/sqlite/renderer.ts +24 -0
package/src/sqlite/table.ts +183 -0
package/src/sqlite.ts +22 -0

package/src/internal/query.ts CHANGED Viewed

@@ -6,6 +6,7 @@ import * as RowSet from "./row-set.js"
 import * as Table from "./table.js"
 import * as ExpressionAst from "./expression-ast.js"
 import * as QueryAst from "./query-ast.js"
+import type * as ProjectionAlias from "./projection-alias.js"
 import type { JsonNode } from "./json/ast.js"
 import type * as JsonPath from "./json/path.js"
 import type { QueryCapability } from "./query-requirements.js"
@@ -24,7 +25,7 @@ import type {
 } from "./predicate/analysis.js"
 import type { AssumeFactsFalse, AssumeFactsTrue, PredicateContext } from "./predicate/context.js"
 import type { FormulaOfPredicate } from "./predicate/normalize.js"
-import type { ColumnKeyOfAst, ColumnKeyOfExpression, PredicateKeyOfAst } from "./predicate/key.js"
+import type { ColumnKey, ColumnKeyOfAst, ColumnKeyOfExpression, PredicateKeyOfAst } from "./predicate/key.js"
 import type { PredicateFormula, TrueFormula } from "./predicate/formula.js"
 import { trueFormula } from "./predicate/runtime.js"
@@ -281,8 +282,57 @@ type JoinGroupingKeys<Keys extends readonly string[]> = Keys extends readonly []
       ? `${Head},${JoinGroupingKeys<Tail>}`
       : string
+type EscapeGroupingBackslashes<Value extends string> = string extends Value
+  ? string
+  : Value extends `${infer Head}\\${infer Tail}`
+    ? `${Head}\\\\${EscapeGroupingBackslashes<Tail>}`
+    : Value
+type EscapeGroupingCommas<Value extends string> = string extends Value
+  ? string
+  : Value extends `${infer Head},${infer Tail}`
+    ? `${Head}\\,${EscapeGroupingCommas<Tail>}`
+    : Value
+type EscapeGroupingPipes<Value extends string> = string extends Value
+  ? string
+  : Value extends `${infer Head}|${infer Tail}`
+    ? `${Head}\\|${EscapeGroupingPipes<Tail>}`
+    : Value
+type EscapeGroupingEquals<Value extends string> = string extends Value
+  ? string
+  : Value extends `${infer Head}=${infer Tail}`
+    ? `${Head}\\=${EscapeGroupingEquals<Tail>}`
+    : Value
+type EscapeGroupingGreaterThan<Value extends string> = string extends Value
+  ? string
+  : Value extends `${infer Head}>${infer Tail}`
+    ? `${Head}\\>${EscapeGroupingGreaterThan<Tail>}`
+    : Value
+type EscapeGroupingText<Value extends string> =
+  EscapeGroupingGreaterThan<
+    EscapeGroupingEquals<
+      EscapeGroupingPipes<
+        EscapeGroupingCommas<
+          EscapeGroupingBackslashes<Value>
+        >
+      >
+    >
+  >
+type JsonStringKeysGroupingKey<Keys extends readonly string[]> = Keys extends readonly []
+  ? ""
+  : Keys extends readonly [infer Head extends string]
+    ? EscapeGroupingText<Head>
+    : Keys extends readonly [infer Head extends string, ...infer Tail extends readonly string[]]
+      ? `${EscapeGroupingText<Head>},${JsonStringKeysGroupingKey<Tail>}`
+      : string
 type JsonSegmentGroupingKey<Segment> =
-  Segment extends JsonPath.KeySegment<infer Key extends string> ? `key:${Key}` :
+  Segment extends JsonPath.KeySegment<infer Key extends string> ? `key:${EscapeGroupingText<Key>}` :
     Segment extends JsonPath.IndexSegment<infer Index extends number> ? `index:${Index}` :
       Segment extends JsonPath.WildcardSegment ? "wildcard" :
         Segment extends JsonPath.SliceSegment<infer Start extends number | undefined, infer End extends number | undefined>
@@ -290,7 +340,7 @@ type JsonSegmentGroupingKey<Segment> =
           : Segment extends JsonPath.DescendSegment
             ? "descend"
             : Segment extends string
-              ? `key:${Segment}`
+              ? `key:${EscapeGroupingText<Segment>}`
               : Segment extends number
                 ? `index:${Segment}`
                 : "unknown"
@@ -306,13 +356,13 @@ type JsonPathGroupingKey<Segments extends readonly any[]> = Segments extends rea
 type JsonOpaquePathGroupingKey<Value> =
   Value extends JsonPath.Path<infer Segments extends readonly JsonPath.CanonicalSegment[]>
     ? `jsonpath:${JsonPathGroupingKey<Segments>}` :
-  Value extends string ? `jsonpath:${Value}` :
+  Value extends string ? `jsonpath:${EscapeGroupingText<Value>}` :
     Value extends Expression.Any ? `jsonpath:${GroupingKeyOfExpression<Value>}` :
       "jsonpath:unknown"
 type JsonEntryGroupingKey<Entry> =
   Entry extends { readonly key: infer Key extends string; readonly value: infer Value extends Expression.Any }
-    ? `${Key}=>${GroupingKeyOfExpression<Value>}`
+    ? `${EscapeGroupingText<Key>}=>${GroupingKeyOfExpression<Value>}`
     : "entry:unknown"
 type JsonEntriesGroupingKey<Entries extends readonly { readonly key: string; readonly value: Expression.Any }[]> = Entries extends readonly []
@@ -338,13 +388,19 @@ type BranchGroupingKeys<
 type GroupingKeyOfAst<Ast extends ExpressionAst.Any> =
   Ast extends ExpressionAst.ColumnNode<infer TableName extends string, infer ColumnName extends string>
-    ? `column:${TableName}.${ColumnName}`
+    ? `column:${ColumnKey<TableName, ColumnName>}`
     : Ast extends ExpressionAst.LiteralNode<infer Value>
       ? `literal:${LiteralGroupingKey<Value>}`
     : Ast extends ExpressionAst.ExcludedNode<infer ColumnName extends string>
       ? `excluded:${ColumnName}`
     : Ast extends ExpressionAst.CastNode<infer Value extends Expression.Any, infer Target extends Expression.DbType.Any>
       ? `cast(${GroupingKeyOfExpression<Value>} as ${Target["dialect"]}:${Target["kind"]})`
+    : Ast extends ExpressionAst.CollateNode<infer Value extends Expression.Any, infer Collation extends readonly [string, ...string[]]>
+      ? `collate(${GroupingKeyOfExpression<Value>},${JsonStringKeysGroupingKey<Collation>})`
+    : Ast extends ExpressionAst.FunctionCallNode<infer Name extends string, infer Args extends readonly Expression.Any[]>
+      ? `function(${EscapeGroupingText<Name>},${JoinGroupingKeys<{
+          readonly [K in keyof Args]: Args[K] extends Expression.Any ? GroupingKeyOfExpression<Args[K]> : never
+        } & readonly string[]>})`
     : Ast extends ExpressionAst.UnaryNode<infer Kind extends ExpressionAst.UnaryKind, infer Value extends Expression.Any>
       ? `${Kind}(${GroupingKeyOfExpression<Value>})`
     : Ast extends ExpressionAst.BinaryNode<infer Kind extends ExpressionAst.BinaryKind, infer Left extends Expression.Any, infer Right extends Expression.Any>
@@ -357,7 +413,7 @@ type GroupingKeyOfAst<Ast extends ExpressionAst.Any> =
           ? Kind extends "jsonGet" | "jsonPath" | "jsonAccess" | "jsonTraverse" | "jsonGetText" | "jsonPathText" | "jsonAccessText" | "jsonTraverseText"
             ? `json(${Kind},${GroupingKeyOfExpression<Extract<Ast["value"] | Ast["base"] | Ast["left"], Expression.Any>>},${JsonPathGroupingKey<Extract<Ast["segments"] | Ast["path"], readonly any[]>>})`
             : Kind extends "jsonHasKey" | "jsonKeyExists" | "jsonHasAnyKeys" | "jsonHasAllKeys"
-              ? `json(${Kind},${GroupingKeyOfExpression<Extract<Ast["value"] | Ast["base"] | Ast["left"], Expression.Any>>},${JoinGroupingKeys<Extract<Ast["keys"], readonly string[]> & readonly string[]>})`
+              ? `json(${Kind},${GroupingKeyOfExpression<Extract<Ast["value"] | Ast["base"] | Ast["left"], Expression.Any>>},${JsonStringKeysGroupingKey<Extract<Ast["keys"], readonly string[]> & readonly string[]>})`
               : Kind extends "jsonConcat" | "jsonMerge" | "jsonDelete" | "jsonDeletePath" | "jsonRemove" | "jsonSet" | "jsonInsert"
                 ? `json(${Kind},${GroupingKeyOfExpression<Extract<Ast["left"] | Ast["base"] | Ast["value"], Expression.Any>>},${GroupingKeyOfExpression<Extract<Ast["right"] | Ast["newValue"] | Ast["insert"], Expression.Any>>},${JsonPathGroupingKey<Extract<Ast["segments"] | Ast["path"], readonly any[]>>})`
                 : Kind extends "jsonPathExists" | "jsonPathMatch"
@@ -1000,6 +1056,138 @@ type JoinPath<Segments extends readonly string[]> = Segments extends readonly []
       ? `${Head}__${JoinPath<Tail>}`
       : string
+type ProjectionAliasOf<
+  Value extends Expression.Any,
+  Path extends readonly string[]
+> = Value extends {
+  readonly [ProjectionAlias.TypeId]: ProjectionAlias.State<infer Alias extends string>
+} ? Alias : JoinPath<Path>
+type SelectionProjectionEntry<
+  Alias extends string,
+  Path extends readonly string[],
+  ExpectedAlias extends string
+> = {
+  readonly alias: Alias
+  readonly path: Path
+  readonly expectedAlias: ExpectedAlias
+}
+type SelectionProjectionEntries<
+  Selection,
+  Path extends readonly string[] = []
+> = Selection extends Expression.Any
+  ? SelectionProjectionEntry<ProjectionAliasOf<Selection, Path>, Path, JoinPath<Path>>
+  : Selection extends Record<string, any>
+    ? {
+        readonly [K in Extract<keyof Selection, string>]:
+          SelectionProjectionEntries<Selection[K], [...Path, K]>
+      }[Extract<keyof Selection, string>]
+    : never
+type SameProjectionPath<
+  Left extends readonly string[],
+  Right extends readonly string[]
+> = Left extends readonly []
+  ? Right extends readonly [] ? true : false
+  : Left extends readonly [infer LeftHead extends string, ...infer LeftTail extends readonly string[]]
+    ? Right extends readonly [infer RightHead extends string, ...infer RightTail extends readonly string[]]
+      ? [LeftHead] extends [RightHead]
+        ? [RightHead] extends [LeftHead]
+          ? SameProjectionPath<LeftTail, RightTail>
+          : false
+        : false
+      : false
+    : false
+type SameProjectionAlias<
+  Left extends string,
+  Right extends string
+> = [Left] extends [Right] ? [Right] extends [Left] ? true : false : false
+type HasDifferentPathForAlias<
+  Entries,
+  Alias extends string,
+  Path extends readonly string[]
+> = Entries extends SelectionProjectionEntry<infer EntryAlias, infer EntryPath, any>
+  ? SameProjectionAlias<EntryAlias, Alias> extends true
+    ? SameProjectionPath<EntryPath, Path> extends true ? never : true
+    : never
+  : never
+type DuplicateProjectionAliases<
+  Entries,
+  AllEntries = Entries
+> = Entries extends SelectionProjectionEntry<infer Alias, infer Path, any>
+  ? string extends Alias ? never
+    : true extends HasDifferentPathForAlias<AllEntries, Alias, Path> ? Alias : never
+  : never
+type ProjectionAliasMismatches<Entries> =
+  Entries extends SelectionProjectionEntry<infer Alias, any, infer ExpectedAlias>
+    ? string extends Alias ? never
+      : string extends ExpectedAlias ? never
+        : SameProjectionAlias<Alias, ExpectedAlias> extends true ? never : Alias
+    : never
+type DerivedProjectionDuplicateAliases<Selection> =
+  DuplicateProjectionAliases<SelectionProjectionEntries<Selection>>
+type DerivedProjectionAliasMismatches<Selection> =
+  ProjectionAliasMismatches<SelectionProjectionEntries<Selection>>
+type IsAny<Value> = 0 extends (1 & Value) ? true : false
+type IsBroadSelection<Selection> =
+  IsAny<Selection> extends true ? true :
+    unknown extends Selection ? true : false
+type DerivedProjectionIssues<Selection> =
+  IsBroadSelection<Selection> extends true
+    ? never
+    : | DerivedProjectionDuplicateAliases<Selection>
+      | DerivedProjectionAliasMismatches<Selection>
+export type DerivedSourceProjectionCompatibilityError<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = PlanValue & {
+  readonly __effect_qb_error__: "effect-qb: derived subqueries require unique path-based projection aliases"
+  readonly __effect_qb_duplicate_projection_aliases__: DerivedProjectionDuplicateAliases<SelectionOfPlan<PlanValue>>
+  readonly __effect_qb_alias_mismatches__: DerivedProjectionAliasMismatches<SelectionOfPlan<PlanValue>>
+  readonly __effect_qb_hint__: "Use unique nested selection paths and do not override projection aliases inside derived subqueries"
+}
+export type DerivedProjectionCompatiblePlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  ValidPlan = PlanValue
+> = [DerivedProjectionIssues<SelectionOfPlan<PlanValue>>] extends [never]
+  ? ValidPlan
+  : ValidPlan & DerivedSourceProjectionCompatibilityError<PlanValue>
+export type DerivedSourceCompatiblePlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = DerivedProjectionCompatiblePlan<PlanValue, CompletePlan<PlanValue>>
+type InlineSourceStatementError<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = PlanValue & {
+  readonly __effect_qb_error__: "effect-qb: inline derived sources only accept select-like query plans"
+  readonly __effect_qb_statement__: StatementOfPlan<PlanValue>
+  readonly __effect_qb_hint__: "Use select(...) or a set operator for as(...) and lateral(...); use with(...) for data-modifying CTEs where supported"
+}
+export type DerivedTableCompatiblePlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = StatementOfPlan<PlanValue> extends SelectLikeStatement
+  ? DerivedSourceCompatiblePlan<PlanValue>
+  : InlineSourceStatementError<PlanValue>
+export type LateralSourceCompatiblePlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = StatementOfPlan<PlanValue> extends SelectLikeStatement
+  ? DerivedProjectionCompatiblePlan<PlanValue>
+  : InlineSourceStatementError<PlanValue>
 type DerivedLeafExpression<
   Value extends Expression.Any,
   Alias extends string,
@@ -1085,6 +1273,12 @@ export type AssumptionsOfPlan<
 export type FactsOfPlan<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
 > = QueryPlanState<PlanValue>["facts"]
+export type CommonSetFacts<
+  Left extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  Right extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = [FactsOfPlan<Left>] extends [FactsOfPlan<Right>]
+  ? [FactsOfPlan<Right>] extends [FactsOfPlan<Left>] ? FactsOfPlan<Left> : EmptyFacts
+  : EmptyFacts
 export type PredicateStateOfPlan<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>
 > = PredicateState<AssumptionsOfPlan<PlanValue>, FactsOfPlan<PlanValue>>
@@ -1217,9 +1411,10 @@ export type AddJoinRequired<
   Available extends Record<string, RowSet.AnySource>,
   JoinedName extends string,
   Predicate extends PredicateInput | never,
-  Kind extends QueryAst.JoinKind = "inner"
+  Kind extends QueryAst.JoinKind = "inner",
+  SourceRequired extends string = never
 > = Exclude<
-  Required | (Predicate extends never ? never : RequiredFromInput<Predicate>),
+  Required | SourceRequired | (Predicate extends never ? never : RequiredFromInput<Predicate>),
   AvailableNames<AvailableAfterJoin<Available, JoinedName, Kind>>
 >
@@ -1744,30 +1939,45 @@ type JsonLiteralSetsForColumn<
   ? Paths
   : {}
+type JsonPathHead<
+  Path extends string,
+  Current extends string = ""
+> = Path extends `\\.${infer Rest}`
+  ? JsonPathHead<Rest, `${Current}.`>
+  : Path extends `\\\\${infer Rest}`
+    ? JsonPathHead<Rest, `${Current}\\`>
+    : Path extends `.${infer Tail}`
+      ? readonly [Current, Tail]
+      : Path extends `${infer Character}${infer Rest}`
+        ? JsonPathHead<Rest, `${Current}${Character}`>
+        : readonly [Current, ""]
 type RefineJsonRuntimeAtPath<
   Runtime,
   Path extends string,
   Values
 > = Runtime extends unknown
-  ? Path extends `${infer Head}.${infer Tail}`
-    ? Runtime extends object
-      ? Head extends keyof Runtime
-        ? RefineJsonRuntimeAtPath<NonNullable<Runtime[Head]>, Tail, Values> extends infer Refined
-          ? [Refined] extends [never]
-            ? never
-            : Omit<Runtime, Head> & { readonly [K in Head]: Refined }
+  ? JsonPathHead<Path> extends readonly [infer Head extends string, infer Tail extends string]
+    ? Tail extends ""
+      ? Runtime extends object
+        ? Head extends keyof Runtime
+          ? RefineRuntimeByAllowedLiterals<NonNullable<Runtime[Head]>, Values> extends infer Refined
+            ? [Refined] extends [never]
+              ? never
+              : Omit<Runtime, Head> & { readonly [K in Head]: Refined }
+            : never
           : never
-        : never
-      : never
-    : Runtime extends object
-      ? Path extends keyof Runtime
-        ? RefineRuntimeByAllowedLiterals<NonNullable<Runtime[Path]>, Values> extends infer Refined
-          ? [Refined] extends [never]
-            ? never
-            : Omit<Runtime, Path> & { readonly [K in Path]: Refined }
+        : RefineRuntimeByAllowedLiterals<NonNullable<Runtime>, Values>
+      : Runtime extends object
+        ? Head extends keyof Runtime
+          ? RefineJsonRuntimeAtPath<NonNullable<Runtime[Head]>, Tail, Values> extends infer Refined
+            ? [Refined] extends [never]
+              ? never
+              : Omit<Runtime, Head> & { readonly [K in Head]: Refined }
+            : never
           : never
         : never
-      : RefineRuntimeByAllowedLiterals<NonNullable<Runtime>, Values>
+    : never
   : never
 type RefineJsonRuntimeWithConstraints<
@@ -1965,9 +2175,9 @@ type IsDialectCompatible<
   EngineDialect extends string
 > = [PlanDialect] extends [never]
   ? true
-  : Extract<PlanDialect, EngineDialect> extends never
-    ? false
-    : true
+  : Exclude<PlanDialect, EngineDialect> extends never
+    ? true
+    : false
 /** Narrows a complete plan to those compatible with a target engine dialect. */
 export type DialectCompatiblePlan<
@@ -1977,15 +2187,27 @@ export type DialectCompatiblePlan<
   ? CompletePlan<PlanValue>
   : DialectCompatibilityError<PlanValue, EngineDialect>
+type SelectLikeStatement = "select" | "set"
+type NestedPlanStatementError<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = PlanValue & {
+  readonly __effect_qb_error__: "effect-qb: subquery expressions only accept select-like query plans"
+  readonly __effect_qb_statement__: StatementOfPlan<PlanValue>
+  readonly __effect_qb_hint__: "Use select(...) or a set operator as the nested subquery expression"
+}
 /** Nested-plan compatibility used by subquery expressions such as `exists(...)`. */
 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
-  ? AggregationCompatiblePlan<PlanValue>
+  ? StatementOfPlan<PlanValue> extends SelectLikeStatement
+    ? AggregationCompatiblePlan<PlanValue>
+    : NestedPlanStatementError<PlanValue>
   : DialectCompatibilityError<PlanValue, EngineDialect>
-type SetOperandStatement = "select" | "set"
+type SetOperandStatement = SelectLikeStatement
 type IsUnion<Value, All = Value> = Value extends any ? ([All] extends [Value] ? false : true) : never
 type SingleSelectedExpressionError<

package/src/internal/renderer.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 import * as Query from "./query.js"
 import type * as Expression from "./scalar.js"
-import { type Projection, validateProjections } from "./projections.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")
@@ -44,7 +45,7 @@ export interface Renderer<Dialect extends string = string> {
   readonly dialect: Dialect
   render<PlanValue extends Query.Plan.Any>(
     plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
-  ): RenderedQuery<any, Dialect>
+  ): RenderedQuery<Query.ResultRow<PlanValue>, Dialect>
 }
 type CustomRender<Dialect extends string> = <PlanValue extends Query.Plan.Any>(
@@ -56,6 +57,29 @@ type CustomRender<Dialect extends string> = <PlanValue extends Query.Plan.Any>(
   readonly valueMappings?: Expression.DriverValueMappings
 }
+const projectionPathKey = (path: readonly string[]): string => JSON.stringify(path)
+const formatProjectionPath = (path: readonly string[]): string => path.join(".")
+const validateProjectionPathsMatchSelection = (
+  plan: Query.Plan.Any,
+  projections: readonly Projection[]
+): void => {
+  const expected = flattenSelection(Query.getAst(plan).select as Record<string, unknown>)
+  const expectedPaths = new Set(expected.map((projection) => projectionPathKey(projection.path)))
+  const actualPaths = new Set(projections.map((projection) => projectionPathKey(projection.path)))
+  for (const projection of projections) {
+    if (!expectedPaths.has(projectionPathKey(projection.path))) {
+      throw new Error(`Projection path ${formatProjectionPath(projection.path)} does not exist in the query selection`)
+    }
+  }
+  for (const projection of expected) {
+    if (!actualPaths.has(projectionPathKey(projection.path))) {
+      throw new Error(`Projection path ${formatProjectionPath(projection.path)} is missing from rendered projections`)
+    }
+  }
+}
 /**
  * Constructs a renderer from a dialect and implementation callback.
  */
@@ -73,9 +97,18 @@ export function make<Dialect extends string>(
   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)
       return {
         sql: rendered.sql,
         params: rendered.params ?? [],

package/src/internal/runtime/driver-value-mapping.ts CHANGED Viewed

@@ -84,6 +84,26 @@ const findMapping = <Key extends MappingKey>(
   return undefined
 }
+const isJsonDbType = (dbType: Expression.DbType.Any | undefined): boolean => {
+  if (dbType === undefined) {
+    return false
+  }
+  if ("base" in dbType) {
+    return isJsonDbType(dbType.base)
+  }
+  if (!("variant" in dbType)) {
+    return false
+  }
+  const variant = dbType.variant as string
+  return variant === "json" || variant === "jsonb"
+}
+const schemaAccepts = (
+  schema: Schema.Schema.Any | undefined,
+  value: unknown
+): boolean =>
+  schema !== undefined && (Schema.is(schema) as (candidate: unknown) => boolean)(value)
 const encodeWithSchema = (
   schema: Schema.Schema.Any | undefined,
   value: unknown
@@ -100,6 +120,32 @@ const encodeWithSchema = (
   }
 }
+const normalizeJsonDriverString = (
+  value: string,
+  context: DriverValueContext
+): unknown | undefined => {
+  if (!isJsonDbType(context.dbType) || context.runtimeSchema === undefined) {
+    return undefined
+  }
+  try {
+    const parsed = JSON.parse(value)
+    if (value.trimStart().startsWith("\"") && schemaAccepts(context.runtimeSchema, parsed)) {
+      return parsed
+    }
+    if (schemaAccepts(context.runtimeSchema, value) && !schemaAccepts(context.runtimeSchema, parsed)) {
+      return value
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError && schemaAccepts(context.runtimeSchema, value)) {
+      return value
+    }
+    if (!(error instanceof SyntaxError)) {
+      throw error
+    }
+  }
+  return undefined
+}
 export const toDriverValue = (
   value: unknown,
   context: DriverValueContext
@@ -107,6 +153,9 @@ export const toDriverValue = (
   if (value === null) {
     return null
   }
+  if (value instanceof Date && Number.isNaN(value.getTime())) {
+    throw new Error("Expected a valid Date value")
+  }
   const dbType = context.dbType
   const encoded = encodeWithSchema(context.runtimeSchema, value)
   let current = encoded.value
@@ -114,6 +163,9 @@ export const toDriverValue = (
   if (custom !== undefined && dbType !== undefined) {
     return custom(current, dbType)
   }
+  if (encoded.encoded && typeof current === "string" && isJsonDbType(dbType)) {
+    return current
+  }
   return dbType === undefined || !encoded.encoded
     ? current
     : normalizeDbValue(dbType, current)
@@ -131,6 +183,12 @@ export const fromDriverValue = (
   if (custom !== undefined && dbType !== undefined) {
     return custom(value, dbType)
   }
+  if (typeof value === "string") {
+    const normalizedJsonString = normalizeJsonDriverString(value, context)
+    if (normalizedJsonString !== undefined) {
+      return normalizedJsonString
+    }
+  }
   return dbType === undefined
     ? value
     : normalizeDbValue(dbType, value)