refactor(sql-ast): replace instanceof with kind discriminants (#253)

closes
[TML-2096](https://linear.app/prisma-company/issue/TML-2096/avoid-instanceof-in-sql-query-ast-methods)

## Before / After

```ts
// BEFORE — dispatch on class identity (breaks with duplicate packages)
if (ast instanceof SelectAst) { ... }
else if (ast instanceof InsertAst) { ... }

// fields typed as abstract classes — consumers must cast to narrow
const expr: Expression = binary.left;
const node = expr as AnyExpression;
switch (node.kind) { ... }
```

```ts
// AFTER — dispatch on structural kind tag (works across module boundaries)
switch (ast.kind) {
  case 'select': ...
  case 'insert': ...
  default: { const _: never = ast; throw new Error(...); }
}

// fields typed as unions — consumers narrow directly
const expr: AnyExpression = binary.left;
switch (expr.kind) { ... }  // no cast needed
```

## Intent

Replace all `instanceof`-based dispatch on SQL query AST node classes
with structural `kind` discriminant tags, then make discriminated union
types the public API surface for all polymorphic AST references.
Abstract base classes become internal implementation details.

`instanceof` checks fail silently when duplicate copies of a package
exist in `node_modules` (a common pnpm workspace scenario). Structural
`kind` dispatch eliminates this failure mode and enables TypeScript
exhaustive `switch` checking at every dispatch site. Using union types
for fields and parameters means `switch (node.kind)` narrows without
casting.

## Change map

### Phase 1: Kind discriminants

- **Implementation (AST definitions)**:
-
[relational-core/src/ast/types.ts](packages/2-sql/4-lanes/relational-core/src/ast/types.ts)
— `kind` tags on 28 concrete classes, narrowed `kind` unions on 5
abstract classes, 5 discriminated union types
-
[relational-core/src/utils/guards.ts](packages/2-sql/4-lanes/relational-core/src/utils/guards.ts)
— simplified `getColumnInfo`
- **Implementation (dispatch migration, 13 files across 6 packages)**:
-
[postgres/src/core/adapter.ts](packages/3-targets/6-adapters/postgres/src/core/adapter.ts)
— 39 checks
-
[sql-runtime/src/plugins/lints.ts](packages/2-sql/5-runtime/src/plugins/lints.ts)
— 6 checks
-
[sql-runtime/src/plugins/budgets.ts](packages/2-sql/5-runtime/src/plugins/budgets.ts)
— 2 checks
-
[sql-orm-client/src/where-binding.ts](packages/3-extensions/sql-orm-client/src/where-binding.ts),
[collection.ts](packages/3-extensions/sql-orm-client/src/collection.ts),
[query-plan-aggregate.ts](packages/3-extensions/sql-orm-client/src/query-plan-aggregate.ts),
[query-plan-meta.ts](packages/3-extensions/sql-orm-client/src/query-plan-meta.ts)
— 19 checks
-
[kysely-lane/src/transform/](packages/2-sql/4-lanes/kysely-lane/src/transform/)
(3 files),
[where-expr.ts](packages/2-sql/4-lanes/kysely-lane/src/where-expr.ts) —
17 checks
-
[sql-lane/src/sql/predicate-builder.ts](packages/2-sql/4-lanes/sql-lane/src/sql/predicate-builder.ts)
— 5 checks
- **Tests (evidence)**:
-
[kind-discriminants.test.ts](packages/2-sql/4-lanes/relational-core/test/ast/kind-discriminants.test.ts)
— foundation tests: all 28 tags, uniqueness, cross-module structural
dispatch
  - 31 test files migrated from `toBeInstanceOf` to `.kind` assertions

### Phase 2: Union-typed fields

- **Implementation (AST core)**:
-
[relational-core/src/ast/types.ts](packages/2-sql/4-lanes/relational-core/src/ast/types.ts)
— un-export 6 abstract classes, update ~15 field types + constructors +
method return types to union types, update
`ExpressionRewriter`/`AstRewriter` interfaces, remove `SqlComparable`
alias, add `AnySqlComparable`/`AnyOperationArg` union types, make
`rewriteComparable`/`foldComparable` exhaustive
-
[relational-core/src/plan.ts](packages/2-sql/4-lanes/relational-core/src/plan.ts),
[src/types.ts](packages/2-sql/4-lanes/relational-core/src/types.ts),
[src/ast/join.ts](packages/2-sql/4-lanes/relational-core/src/ast/join.ts),
[src/operations-registry.ts](packages/2-sql/4-lanes/relational-core/src/operations-registry.ts)
— relational-core internal consumers
- **Implementation (propagation, 24 files across 5 packages)**:
-
[kysely-lane/src/transform/](packages/2-sql/4-lanes/kysely-lane/src/transform/)
— `WhereExpr` → `AnyWhereExpr`, `ColumnRef` casts removed
- [sql-lane/src/sql/](packages/2-sql/4-lanes/sql-lane/src/sql/) —
`Expression` → `AnyExpression`, `WhereExpr` → `AnyWhereExpr`,
`SqlComparable` → `AnySqlComparable`
- [sql-runtime/src/](packages/2-sql/5-runtime/src/) — `QueryAst` →
`AnyQueryAst`, `FromSource` → `AnyFromSource`, exhaustive switches added
- [sql-orm-client/src/](packages/3-extensions/sql-orm-client/src/) (~12
files) — all abstract class imports → union types
- [postgres/src/](packages/3-targets/6-adapters/postgres/src/) —
`QueryAst` → `AnyQueryAst`, `Expression` → `AnyExpression`, `FromSource`
→ `AnyFromSource`, `WhereExpr` → `AnyWhereExpr`, casts removed, error
messages aligned to `kind`-based pattern
- **Tests (evidence)**:
-
[adapter.test.ts](packages/3-targets/6-adapters/postgres/test/adapter.test.ts)
— `class UnsupportedAst extends QueryAst` replaced with plain-object
cast (abstract class no longer importable)
-
[test-helpers.ts](packages/2-sql/4-lanes/relational-core/test/ast/test-helpers.ts),
[rich-ast.test.ts](packages/2-sql/4-lanes/relational-core/test/ast/rich-ast.test.ts)
— `Expression | ParamRef | LiteralExpr` → `AnyOperationArg`
- 5 ORM client test files updated from `WhereExpr` to `AnyWhereExpr`
type annotations

## The story

### Phase 1: Kind discriminants

1. **Add structural `kind` tags to every AST node.** Each of the 28
concrete AST classes gets `readonly kind = '<tag>' as const`. The root
`AstNode` declares `abstract readonly kind: string`, and the 5
intermediate abstract classes (`QueryAst`, `FromSource`, `Expression`,
`WhereExpr`, `InsertOnConflictAction`) narrow it to their valid tag
unions — so adding a new subclass with the wrong `kind` is a compile
error.

2. **Export discriminated union types.** `AnyQueryAst`, `AnyFromSource`,
`AnyExpression`, `AnyWhereExpr`, and `AnyInsertOnConflictAction` enable
`switch (node.kind)` with exhaustive `never` defaults in dispatch sites
that need full type narrowing.

3. **Migrate all ~112 production `instanceof` checks to `kind`-based
dispatch.** Multi-branch chains become exhaustive `switch` statements.
Single-branch guards become `if (node.kind === 'tag')`. Classes imported
solely for `instanceof` are converted to type-only imports, reducing
runtime coupling.

4. **Migrate all ~117 test `toBeInstanceOf` assertions.** Test
assertions now validate the `kind` discriminant rather than class
identity, ensuring tests exercise the structural dispatch mechanism.

5. **Clean up follow-on sites.** The `expressionKinds` Set in
`predicate-builder.ts` (redundant now that `Expression.kind` is
type-narrowed) is removed. The `whereExprKinds` Set in `collection.ts`
is typed against `WhereExpr['kind']`. A dead branch in `JoinAst.rewrite`
(predating this migration) is removed.

### Phase 2: Union-typed fields

6. **Replace abstract class types with discriminated unions
everywhere.** All ~15 field declarations, constructor parameters,
composite type aliases (`ProjectionExpr`, `JoinOnExpr`, `WhereArg`),
`ExpressionRewriter`/`AstRewriter` interface return types, and abstract
method return types (`rewrite()`, `not()`, `toExpr()`) are updated to
reference union types instead of abstract base classes. `SqlComparable`
is removed in favor of `AnySqlComparable`.

7. **Propagate union types to all downstream packages.** 24 files across
`kysely-lane`, `sql-lane`, `sql-runtime`, `sql-orm-client`, and
`postgres` are updated. All imports of abstract base classes for type
annotations are replaced with union type imports. Casts that existed
solely for `kind`-narrowing (e.g., `const node = ast as AnyQueryAst`)
are removed.

8. **Un-export all 6 abstract base classes.** `AstNode`, `QueryAst`,
`FromSource`, `Expression`, `WhereExpr`, and `InsertOnConflictAction`
become module-private. They remain in the file for method inheritance
but are no longer part of the public API surface.

## Behavior changes & evidence

- **Every concrete AST class exposes a `readonly kind` discriminant with
a unique kebab-case literal type.** Dispatch sites can structurally
identify nodes without relying on class identity.
- **Why**: `instanceof` fails silently when multiple copies of a package
coexist in `node_modules`. Structural `kind` tags work regardless of
module resolution.
- **Implementation**:
[types.ts](packages/2-sql/4-lanes/relational-core/src/ast/types.ts)
- **Tests**:
[kind-discriminants.test.ts](packages/2-sql/4-lanes/relational-core/test/ast/kind-discriminants.test.ts)
— tests all 28 tags, uniqueness, and cross-module plain-object dispatch

- **Intermediate abstract classes narrow `kind` to their valid tag
union.** Adding a new `Expression` subclass with `kind = 'invalid'` is a
compile error.
- **Why**: Prevents silent dispatch gaps when the class hierarchy grows.
- **Implementation**:
[types.ts](packages/2-sql/4-lanes/relational-core/src/ast/types.ts)

- **All production dispatch uses `kind`-based switching.** Zero
`instanceof` on AST classes remain in production code.
- **Implementation**: 13 source files across 6 packages (see change map)
  - **Tests**: Full test suite passes

- **All polymorphic AST fields, parameters, and return types use
discriminated union types.** `switch (node.kind)` narrows directly
without casting.
- **Why**: Abstract class types could not be narrowed by `kind` checks —
consumers had to cast to the union first. Union types eliminate this
friction.
- **Implementation**:
[types.ts](packages/2-sql/4-lanes/relational-core/src/ast/types.ts) + 24
downstream files

- **Abstract base classes are no longer exported.** They serve only as
internal implementation details for method inheritance and immutability
(`freeze()`).
- **Why**: With union types as the public API, there is no reason for
consumers to reference the abstract classes.
- **Implementation**:
[types.ts](packages/2-sql/4-lanes/relational-core/src/ast/types.ts)
- **Tests**:
[adapter.test.ts](packages/3-targets/6-adapters/postgres/test/adapter.test.ts)
— `UnsupportedAst` class replaced with plain-object cast

- **No runtime behavior change**: the class hierarchy is preserved. Both
phases are pure dispatch-mechanism and type-system migrations.

## Compatibility / migration / risk

- **No breaking API changes for in-repo consumers.** The `kind` property
is additive; fields gain more precise types (narrower unions instead of
broad abstract class).
- **External consumers that subclass abstract AST classes will break.**
Since the abstract classes are no longer exported, code outside this
repo that extends `QueryAst`, `Expression`, etc. will fail to compile.
This is intentional.
- **`toEqual` assertions against plain objects break** if the class now
has a `kind` property that the plain object lacks. All affected tests
were updated to use AST constructors (e.g. `ProjectionItem.of(...)`
instead of `{ alias, expr }`).

## Follow-ups / open questions

- ~90+ `toBeInstanceOf` calls on non-AST classes (e.g. `Collection`,
`PostCollection`) remain untouched — those are outside the scope of this
migration.

## Non-goals / intentionally out of scope

- Removing the class hierarchy itself (classes are preserved for method
inheritance, immutability via `freeze()`, and factory methods).
- Adding generics (CRTP / F-bounded polymorphism) to the abstract
classes (evaluated and rejected).
- Migrating `instanceof` on non-AST types (e.g. `Error`, `Date`,
`Collection`).

---------

Co-authored-by: Alexey Orlenko <alex@aqrln.net>

Author: wmadden

.claude/scripts/worktree-create.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 import { execSync } from 'node:child_process';
-import { text } from 'node:stream/consumers';
 import { resolve } from 'node:path';
+import { text } from 'node:stream/consumers';
 
 const input = JSON.parse(await text(process.stdin));
 

packages/2-sql/4-lanes/kysely-lane/src/plan.test.ts

@@ -2,7 +2,7 @@ import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
 import {
   type BinaryExpr,
   ParamRef,
-  SelectAst,
+  type SelectAst,
   TableSource,
 } from '@prisma-next/sql-relational-core/ast';
 import type { CompiledQuery } from 'kysely';
@@ -99,7 +99,7 @@ describe('buildKyselyPlan', () => {
   it('assembles plan metadata with stable refs and limit annotations', () => {
     const plan = buildKyselyPlan(contract, createSelectCompiledQuery());
 
-    expect(plan.ast).toBeInstanceOf(SelectAst);
+    expect(plan.ast.kind).toBe('select');
     const ast = plan.ast as SelectAst;
     expect(ast.from).toEqual(TableSource.named('user'));
     expect((ast.where as BinaryExpr).left).toEqual(ast.projection[0]!.expr);
@@ -275,7 +275,7 @@ describe('buildKyselyPlan', () => {
     } as unknown as CompiledQuery<unknown>;
 
     const plan = buildKyselyPlan(contract, query);
-    expect(plan.ast).toBeInstanceOf(SelectAst);
+    expect(plan.ast.kind).toBe('select');
     const ast = plan.ast as SelectAst;
     expect(ast.joins).toHaveLength(1);
     expect(ast.joins?.[0]?.joinType).toBe('left');

packages/2-sql/4-lanes/kysely-lane/src/transform/transform-context.ts

@@ -1,9 +1,9 @@
 import type { ParamDescriptor, PlanRefs } from '@prisma-next/contract/types';
 import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
-import type { QueryAst } from '@prisma-next/sql-relational-core/ast';
+import type { AnyQueryAst } from '@prisma-next/sql-relational-core/ast';
 
 export interface TransformResult {
-  readonly ast: QueryAst;
+  readonly ast: AnyQueryAst;
   readonly metaAdditions: {
     readonly refs: PlanRefs;
     readonly paramDescriptors: ReadonlyArray<ParamDescriptor>;

packages/2-sql/4-lanes/kysely-lane/src/transform/transform-dml.ts

@@ -5,7 +5,7 @@ import {
   InsertAst,
   InsertOnConflict,
   type InsertValue,
-  ParamRef,
+  type ParamRef,
   UpdateAst,
 } from '@prisma-next/sql-relational-core/ast';
 import {
@@ -37,7 +37,7 @@ import { expandSelectAll } from './transform-select';
 import { resolveColumnRef, transformTableRef, validateColumn } from './transform-validate';
 
 function assertParamRef(value: ReturnType<typeof transformValue>): ParamRef {
-  if (!(value instanceof ParamRef)) {
+  if (value.kind !== 'param-ref') {
     throw new KyselyTransformError(
       'Only parameterized VALUES are supported in Kysely transform lane',
       KYSELY_TRANSFORM_ERROR_CODES.UNSUPPORTED_NODE,

packages/2-sql/4-lanes/kysely-lane/src/transform/transform-expr.ts

@@ -1,9 +1,9 @@
 import type { ParamDescriptor } from '@prisma-next/contract/types';
-import type { BinaryOp, JoinOnExpr, WhereExpr } from '@prisma-next/sql-relational-core/ast';
+import type { AnyWhereExpr, BinaryOp, JoinOnExpr } from '@prisma-next/sql-relational-core/ast';
 import {
   AndExpr,
   BinaryExpr,
-  ColumnRef,
+  type ColumnRef,
   EqColJoinOn,
   ListLiteralExpr,
   LiteralExpr,
@@ -113,7 +113,7 @@ function flattenLogical(
   logicalKind: 'and' | 'or',
   ctx: TransformContext,
   defaultTable: string | undefined,
-  out: WhereExpr[],
+  out: AnyWhereExpr[],
 ): void {
   const current = ParensNode.is(node) ? node.node : node;
   if (logicalKind === 'and' && AndNode.is(current)) {
@@ -159,7 +159,7 @@ export function transformWhereExpr(
   node: unknown,
   ctx: TransformContext,
   defaultTable?: string,
-): WhereExpr | undefined {
+): AnyWhereExpr | undefined {
   if (!node) {
     return undefined;
   }
@@ -173,15 +173,15 @@ export function transformWhereExpr(
   }
 
   if (AndNode.is(node)) {
-    const exprs: WhereExpr[] = [];
+    const exprs: AnyWhereExpr[] = [];
     flattenLogical(node, 'and', ctx, defaultTable, exprs);
     if (exprs.length === 0) return undefined;
     if (exprs.length === 1) return exprs[0];
     return AndExpr.of(exprs);
   }
 
   if (OrNode.is(node)) {
-    const exprs: WhereExpr[] = [];
+    const exprs: AnyWhereExpr[] = [];
     flattenLogical(node, 'or', ctx, defaultTable, exprs);
     if (exprs.length === 0) return undefined;
     if (exprs.length === 1) return exprs[0];
@@ -252,10 +252,10 @@ export function transformJoinOn(
   }
 
   if (
-    expr instanceof BinaryExpr &&
+    expr.kind === 'binary' &&
     expr.op === 'eq' &&
-    expr.left instanceof ColumnRef &&
-    expr.right instanceof ColumnRef
+    expr.left.kind === 'column-ref' &&
+    expr.right.kind === 'column-ref'
   ) {
     return EqColJoinOn.of(expr.left, expr.right);
   }

packages/2-sql/4-lanes/kysely-lane/src/transform/transform.ts

@@ -7,9 +7,8 @@
  * - Ambiguous selectAll in multi-table scope → AMBIGUOUS_SELECT_ALL
  * - Unsupported node kinds → UNSUPPORTED_NODE
  */
-import type { PlanRefs } from '@prisma-next/contract/types';
 import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
-import { ColumnRef, type QueryAst, SelectAst } from '@prisma-next/sql-relational-core/ast';
+import type { AnyQueryAst } from '@prisma-next/sql-relational-core/ast';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { DeleteQueryNode, InsertQueryNode, SelectQueryNode, UpdateQueryNode } from 'kysely';
 import { KYSELY_TRANSFORM_ERROR_CODES, KyselyTransformError } from './errors';
@@ -21,10 +20,6 @@ import { transformSelect } from './transform-select';
 
 export type { TransformResult };
 
-function extractRefsFromAst(ast: QueryAst): PlanRefs {
-  return ast.collectRefs();
-}
-
 export interface TransformResultWithParams extends TransformResult {
   readonly params: readonly unknown[];
 }
@@ -49,7 +44,7 @@ export function transformKyselyToPnAst(
 
   const ctx = createContext(contract, parameters);
 
-  let ast: QueryAst;
+  let ast: AnyQueryAst;
   if (SelectQueryNode.is(query)) {
     ast = transformSelect(query, ctx);
   } else if (InsertQueryNode.is(query)) {
@@ -68,7 +63,7 @@ export function transformKyselyToPnAst(
     );
   }
 
-  const refs = extractRefsFromAst(ast);
+  const refs = ast.collectRefs();
 
   const paramDescriptors = ctx.paramDescriptors.map((descriptor, index) => ({
     ...descriptor,
@@ -77,19 +72,20 @@ export function transformKyselyToPnAst(
 
   let projection: Record<string, string> | undefined;
   let projectionTypes: Record<string, string> | undefined;
-  if (ast instanceof SelectAst) {
+  const select = ast.kind === 'select' ? ast : undefined;
+  if (select) {
     projection = Object.fromEntries(
-      ast.projection.map((projected) => [
-        projected.alias,
-        projected.expr instanceof ColumnRef ? projected.expr.column : projected.alias,
-      ]),
+      select.projection.map((projected) => {
+        const col = projected.expr.kind === 'column-ref' ? projected.expr : undefined;
+        return [projected.alias, col?.column ?? projected.alias];
+      }),
     );
 
     projectionTypes = {};
-    for (const projected of ast.projection) {
-      if (projected.expr instanceof ColumnRef) {
-        const column =
-          ctx.contract.storage.tables[projected.expr.table]?.columns[projected.expr.column];
+    for (const projected of select.projection) {
+      const col = projected.expr.kind === 'column-ref' ? projected.expr : undefined;
+      if (col) {
+        const column = ctx.contract.storage.tables[col.table]?.columns[col.column];
         if (column) {
           projectionTypes[projected.alias] = column.codecId;
         }
@@ -105,8 +101,8 @@ export function transformKyselyToPnAst(
       'projectionTypes',
       projectionTypes && Object.keys(projectionTypes).length > 0 ? projectionTypes : undefined,
     ),
-    ...ifDefined('selectAllIntent', ast instanceof SelectAst ? ast.selectAllIntent : undefined),
-    ...ifDefined('limit', ast instanceof SelectAst ? ast.limit : undefined),
+    ...ifDefined('selectAllIntent', select?.selectAllIntent),
+    ...ifDefined('limit', select?.limit),
   };
 
   return { ast, metaAdditions };
@@ -131,7 +127,7 @@ export function transformKyselyToPnAstCollectingParams(
 
   const ctx = createContext(contract);
 
-  let ast: QueryAst;
+  let ast: AnyQueryAst;
   if (SelectQueryNode.is(query)) {
     ast = transformSelect(query, ctx);
   } else if (InsertQueryNode.is(query)) {
@@ -150,7 +146,7 @@ export function transformKyselyToPnAstCollectingParams(
     );
   }
 
-  const refs = extractRefsFromAst(ast);
+  const refs = ast.collectRefs();
 
   const paramDescriptors = ctx.paramDescriptors.map((descriptor, index) => ({
     ...descriptor,
@@ -159,19 +155,20 @@ export function transformKyselyToPnAstCollectingParams(
 
   let projection: Record<string, string> | undefined;
   let projectionTypes: Record<string, string> | undefined;
-  if (ast instanceof SelectAst) {
+  const select = ast.kind === 'select' ? ast : undefined;
+  if (select) {
     projection = Object.fromEntries(
-      ast.projection.map((projected) => [
-        projected.alias,
-        projected.expr instanceof ColumnRef ? projected.expr.column : projected.alias,
-      ]),
+      select.projection.map((projected) => {
+        const col = projected.expr.kind === 'column-ref' ? projected.expr : undefined;
+        return [projected.alias, col?.column ?? projected.alias];
+      }),
     );
 
     projectionTypes = {};
-    for (const projected of ast.projection) {
-      if (projected.expr instanceof ColumnRef) {
-        const column =
-          ctx.contract.storage.tables[projected.expr.table]?.columns[projected.expr.column];
+    for (const projected of select.projection) {
+      const col = projected.expr.kind === 'column-ref' ? projected.expr : undefined;
+      if (col) {
+        const column = ctx.contract.storage.tables[col.table]?.columns[col.column];
         if (column) {
           projectionTypes[projected.alias] = column.codecId;
         }
@@ -187,8 +184,8 @@ export function transformKyselyToPnAstCollectingParams(
       'projectionTypes',
       projectionTypes && Object.keys(projectionTypes).length > 0 ? projectionTypes : undefined,
     ),
-    ...ifDefined('selectAllIntent', ast instanceof SelectAst ? ast.selectAllIntent : undefined),
-    ...ifDefined('limit', ast instanceof SelectAst ? ast.limit : undefined),
+    ...ifDefined('selectAllIntent', select?.selectAllIntent),
+    ...ifDefined('limit', select?.limit),
   };
 
   return { ast, params: ctx.params, metaAdditions };

packages/2-sql/4-lanes/kysely-lane/src/where-expr.ast.test.ts

@@ -156,13 +156,13 @@ describe('buildKyselyWhereExpr nested AST traversal', () => {
     expect(bound.expr).toBeInstanceOf(ExistsExpr);
     const exists = bound.expr as ExistsExpr;
     const subquery = exists.subquery;
-    expect(subquery.from).toBeInstanceOf(DerivedTableSource);
+    expect(subquery.from.kind).toEqual('derived-table-source');
     expect(((subquery.from as DerivedTableSource).query.where as BinaryExpr).right).toEqual(
       ParamRef.of(3, 'kind'),
     );
 
     const join = subquery.joins?.[0];
-    expect(join?.source).toBeInstanceOf(DerivedTableSource);
+    expect(join?.source.kind).toEqual('derived-table-source');
     expect((join?.on as BinaryExpr).right).toEqual(ParamRef.of(1, 'userId'));
     expect(((join?.source as DerivedTableSource).query.where as BinaryExpr).right).toEqual(
       ParamRef.of(4, 'title'),

packages/2-sql/4-lanes/kysely-lane/src/where-expr.ts

@@ -3,8 +3,6 @@ import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
 import {
   type BoundWhereExpr,
   ListLiteralExpr,
-  ParamRef,
-  SelectAst,
   type ToWhereExpr,
 } from '@prisma-next/sql-relational-core/ast';
 import type { CompiledQuery } from 'kysely';
@@ -29,7 +27,7 @@ export function buildKyselyWhereExpr<Row>(
   options: BuildKyselyPlanOptions = {},
 ): ToWhereExpr {
   const plan = buildKyselyPlan(contract, compiledQuery, options);
-  if (!(plan.ast instanceof SelectAst) || !plan.ast.where) {
+  if (plan.ast.kind !== 'select' || !plan.ast.where) {
     throw new Error('whereExpr(...) requires a select query with a where clause');
   }
 
@@ -97,7 +95,7 @@ function remapParamIndexes(
     listLiteral: (list) =>
       new ListLiteralExpr(
         list.values.map((value) => {
-          if (!(value instanceof ParamRef)) {
+          if (value.kind !== 'param-ref') {
             return value;
           }
           const newIndex = remap.get(value.index);

packages/2-sql/4-lanes/relational-core/src/ast/join.ts

@@ -1,7 +1,7 @@
 import { planInvalid } from '@prisma-next/plan';
 import type { AnyColumnBuilder, JoinOnBuilder, JoinOnPredicate } from '../types';
 import { isColumnBuilder } from '../types';
-import { EqColJoinOn, type FromSource, JoinAst } from './types';
+import { EqColJoinOn, JoinAst } from './types';
 
 class JoinOnBuilderImpl implements JoinOnBuilder {
   eqCol(left: AnyColumnBuilder, right: AnyColumnBuilder): JoinOnPredicate {
@@ -27,7 +27,7 @@ class JoinOnBuilderImpl implements JoinOnBuilder {
   }
 }
 
-export { EqColJoinOn, JoinAst, type FromSource };
+export { EqColJoinOn, JoinAst };
 
 export function createJoinOnBuilder(): JoinOnBuilder {
   return new JoinOnBuilderImpl();