refactor(scalar-arrays): expose raw expression AST on ResolvedAttributeArg (slice 2 N1)

Replace the decoded ResolvedExpr union with the parser ExpressionAst node
directly on ResolvedAttributeArg, per code-owner review. List-default parsing
narrows via the AST classes (ArrayLiteralAst/StringLiteralExprAst/...) instead
of a bespoke decoded shape. The stringified value is kept, as it is still
consumed by scalar/function-call/relation-name/authoring-arg parsing.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Signed-off-by: Serhii Tatarintsev <tatarintsev@prisma.io>

Author: SevInf

packages/1-framework/2-authoring/psl-parser/src/exports/index.ts

@@ -54,7 +54,6 @@ export type {
   NamespaceSymbol,
   ResolvedAttribute,
   ResolvedAttributeArg,
-  ResolvedExpr,
   ResolvedNamedTypeBinding,
   ResolvedTypeConstructorCall,
   ScalarSymbol,

packages/1-framework/2-authoring/psl-parser/src/resolve.ts

@@ -5,40 +5,17 @@ import type {
   FieldAttributeAst,
   ModelAttributeAst,
 } from './syntax/ast/attributes';
-import {
-  ArrayLiteralAst,
-  BooleanLiteralExprAst,
-  type ExpressionAst,
-  FunctionCallAst,
-  NumberLiteralExprAst,
-  ObjectLiteralExprAst,
-  StringLiteralExprAst,
-} from './syntax/ast/expressions';
-import { IdentifierAst } from './syntax/ast/identifier';
+import type { ExpressionAst } from './syntax/ast/expressions';
 import type { QualifiedNameAst } from './syntax/ast/qualified-name';
 import type { TypeAnnotationAst } from './syntax/ast/type-annotation';
 import { printSyntax } from './syntax/ast-helpers';
 import type { SyntaxNode } from './syntax/red';
 
-/**
- * A structurally decoded attribute-argument expression. Consumers that need the
- * shape of an expression (e.g. array-literal `@default([...])`) read this instead
- * of re-parsing the stringified {@link ResolvedAttributeArg.value}.
- */
-export type ResolvedExpr =
-  | { readonly kind: 'string'; readonly value: string }
-  | { readonly kind: 'number'; readonly value: number }
-  | { readonly kind: 'boolean'; readonly value: boolean }
-  | { readonly kind: 'array'; readonly elements: readonly ResolvedExpr[] }
-  | { readonly kind: 'object' }
-  | { readonly kind: 'call'; readonly path: readonly string[] }
-  | { readonly kind: 'identifier'; readonly name: string };
-
 export interface ResolvedAttributeArg {
   readonly kind: 'positional' | 'named';
   readonly name?: string;
   readonly value: string;
-  readonly expression?: ResolvedExpr;
+  readonly expression?: ExpressionAst;
   readonly span: PslSpan;
 }
 
@@ -93,55 +70,18 @@ function readResolvedArgList(
   const args: ResolvedAttributeArg[] = [];
   for (const arg of argList.args()) {
     const name = arg.name()?.name();
-    const value = arg.value();
-    const expression = decodeExpression(value);
+    const expression = arg.value();
     args.push({
       kind: name !== undefined ? 'named' : 'positional',
       ...(name !== undefined ? { name } : {}),
-      value: renderExpression(value),
+      value: renderExpression(expression),
       ...(expression !== undefined ? { expression } : {}),
       span: nodePslSpan(arg.syntax, sourceFile),
     });
   }
   return args;
 }
 
-function decodeExpression(expression: ExpressionAst | undefined): ResolvedExpr | undefined {
-  if (expression === undefined) return undefined;
-  if (expression instanceof StringLiteralExprAst) {
-    const value = expression.value();
-    return value === undefined ? undefined : { kind: 'string', value };
-  }
-  if (expression instanceof NumberLiteralExprAst) {
-    const value = expression.value();
-    return value === undefined ? undefined : { kind: 'number', value };
-  }
-  if (expression instanceof BooleanLiteralExprAst) {
-    const value = expression.value();
-    return value === undefined ? undefined : { kind: 'boolean', value };
-  }
-  if (expression instanceof ArrayLiteralAst) {
-    const elements: ResolvedExpr[] = [];
-    for (const element of expression.elements()) {
-      const decoded = decodeExpression(element);
-      if (decoded === undefined) return undefined;
-      elements.push(decoded);
-    }
-    return { kind: 'array', elements };
-  }
-  if (expression instanceof FunctionCallAst) {
-    return { kind: 'call', path: expression.path() };
-  }
-  if (expression instanceof IdentifierAst) {
-    const name = expression.name();
-    return name === undefined ? undefined : { kind: 'identifier', name };
-  }
-  if (expression instanceof ObjectLiteralExprAst) {
-    return { kind: 'object' };
-  }
-  return undefined;
-}
-
 function attributeName(name: QualifiedNameAst | undefined): string {
   return name?.path().join('.') ?? '';
 }

packages/1-framework/2-authoring/psl-parser/src/symbol-table.ts

@@ -27,7 +27,6 @@ import type { SyntaxNode } from './syntax/red';
 export type {
   ResolvedAttribute,
   ResolvedAttributeArg,
-  ResolvedExpr,
   ResolvedTypeConstructorCall,
 } from './resolve';
 

packages/2-sql/2-authoring/contract-psl/src/psl-attribute-parsing.ts

@@ -1,7 +1,8 @@
 import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
 import type { ControlPolicy } from '@prisma-next/contract/types';
-import type { PslSpan, ResolvedAttribute, ResolvedExpr } from '@prisma-next/psl-parser';
+import type { PslSpan, ResolvedAttribute } from '@prisma-next/psl-parser';
 import { parseQuotedStringLiteral } from '@prisma-next/psl-parser';
+import type { ExpressionAst } from '@prisma-next/psl-parser/syntax';
 
 export { parseQuotedStringLiteral };
 
@@ -32,7 +33,7 @@ export function getNamedArgument(attribute: ResolvedAttribute, name: string): st
 export function getPositionalArgumentEntry(
   attribute: ResolvedAttribute,
   index = 0,
-): { value: string; expression?: ResolvedExpr; span: PslSpan } | undefined {
+): { value: string; expression?: ExpressionAst; span: PslSpan } | undefined {
   const entries = attribute.args.filter((arg) => arg.kind === 'positional');
   const entry = entries[index];
   if (!entry || entry.kind !== 'positional') {

packages/2-sql/2-authoring/contract-psl/src/psl-column-resolution.ts

@@ -23,9 +23,15 @@ import type {
   FieldSymbol,
   PslSpan,
   ResolvedAttribute,
-  ResolvedExpr,
   ResolvedTypeConstructorCall,
 } from '@prisma-next/psl-parser';
+import {
+  ArrayLiteralAst,
+  BooleanLiteralExprAst,
+  type ExpressionAst,
+  NumberLiteralExprAst,
+  StringLiteralExprAst,
+} from '@prisma-next/psl-parser/syntax';
 import { blindCast } from '@prisma-next/utils/casts';
 
 import {
@@ -718,22 +724,28 @@ type ListDefaultParse =
   | { readonly kind: 'scalar' }
   | undefined;
 
-function parseListDefaultExpression(expression: ResolvedExpr | undefined): ListDefaultParse {
+function decodeLiteralElement(element: ExpressionAst): string | number | boolean | undefined {
+  if (element instanceof StringLiteralExprAst) return element.value();
+  if (element instanceof NumberLiteralExprAst) return element.value();
+  if (element instanceof BooleanLiteralExprAst) return element.value();
+  return undefined;
+}
+
+function parseListDefaultExpression(expression: ExpressionAst | undefined): ListDefaultParse {
   if (expression === undefined) return undefined;
   if (
-    expression.kind === 'string' ||
-    expression.kind === 'number' ||
-    expression.kind === 'boolean'
+    expression instanceof StringLiteralExprAst ||
+    expression instanceof NumberLiteralExprAst ||
+    expression instanceof BooleanLiteralExprAst
   ) {
     return { kind: 'scalar' };
   }
-  if (expression.kind !== 'array') return undefined;
+  if (!(expression instanceof ArrayLiteralAst)) return undefined;
   const value: (string | number | boolean)[] = [];
-  for (const element of expression.elements) {
-    if (element.kind !== 'string' && element.kind !== 'number' && element.kind !== 'boolean') {
-      return undefined;
-    }
-    value.push(element.value);
+  for (const element of expression.elements()) {
+    const decoded = decodeLiteralElement(element);
+    if (decoded === undefined) return undefined;
+    value.push(decoded);
   }
   return { kind: 'array', value };
 }