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

.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();