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

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,14 @@
 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,
+  WhereExpr,
+} from '@prisma-next/sql-relational-core/ast';
 import {
   AndExpr,
   BinaryExpr,
-  ColumnRef,
+  type ColumnRef,
   EqColJoinOn,
   ListLiteralExpr,
   LiteralExpr,
@@ -251,13 +256,14 @@ export function transformJoinOn(
     );
   }
 
+  const narrowed = expr as AnyWhereExpr;
   if (
-    expr instanceof BinaryExpr &&
-    expr.op === 'eq' &&
-    expr.left instanceof ColumnRef &&
-    expr.right instanceof ColumnRef
+    narrowed.kind === 'binary' &&
+    narrowed.op === 'eq' &&
+    narrowed.left.kind === 'column-ref' &&
+    narrowed.right.kind === 'column-ref'
   ) {
-    return EqColJoinOn.of(expr.left, expr.right);
+    return EqColJoinOn.of(narrowed.left as ColumnRef, narrowed.right as ColumnRef);
   }
 
   return expr;

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

@@ -9,7 +9,7 @@
  */
 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, ColumnRef } 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,7 +21,7 @@ import { transformSelect } from './transform-select';
 
 export type { TransformResult };
 
-function extractRefsFromAst(ast: QueryAst): PlanRefs {
+function extractRefsFromAst(ast: AnyQueryAst): PlanRefs {
   return ast.collectRefs();
 }
 
@@ -49,7 +49,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)) {
@@ -77,19 +77,21 @@ 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 as ColumnRef) : 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 as ColumnRef) : undefined;
+      if (col) {
+        const column = ctx.contract.storage.tables[col.table]?.columns[col.column];
         if (column) {
           projectionTypes[projected.alias] = column.codecId;
         }
@@ -105,8 +107,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 +133,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)) {
@@ -159,19 +161,21 @@ 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 as ColumnRef) : 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 as ColumnRef) : undefined;
+      if (col) {
+        const column = ctx.contract.storage.tables[col.table]?.columns[col.column];
         if (column) {
           projectionTypes[projected.alias] = column.codecId;
         }
@@ -187,8 +191,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.ts

@@ -3,8 +3,7 @@ import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
 import {
   type BoundWhereExpr,
   ListLiteralExpr,
-  ParamRef,
-  SelectAst,
+  type SelectAst,
   type ToWhereExpr,
 } from '@prisma-next/sql-relational-core/ast';
 import type { CompiledQuery } from 'kysely';
@@ -29,21 +28,25 @@ 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') {
+    throw new Error('whereExpr(...) requires a select query with a where clause');
+  }
+  const selectAst = plan.ast as SelectAst;
+  if (!selectAst.where) {
     throw new Error('whereExpr(...) requires a select query with a where clause');
   }
 
-  const indexes = [...new Set(collectParamIndexes(plan.ast.where))].sort((a, b) => a - b);
+  const indexes = [...new Set(collectParamIndexes(selectAst.where))].sort((a, b) => a - b);
   if (indexes.length === 0) {
     return new LaneWhereExpr({
-      expr: plan.ast.where,
+      expr: selectAst.where,
       params: [],
       paramDescriptors: [],
     });
   }
 
   const remap = new Map<number, number>(indexes.map((index, i) => [index, i + 1]));
-  const remappedExpr = remapParamIndexes(plan.ast.where, remap);
+  const remappedExpr = remapParamIndexes(selectAst.where, remap);
   const params = indexes.map((index) => {
     if (index <= 0 || index > plan.params.length) {
       throw new Error(`whereExpr(...) payload is invalid: missing param value for index ${index}`);
@@ -97,7 +100,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);