@prisma-next/psl-parser 0.14.0-dev.6 → 0.14.0-dev.60

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@prisma-next/psl-parser",
-  "version": "0.14.0-dev.6",
+  "version": "0.14.0-dev.60",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Reusable parser for Prisma Schema Language (PSL)",
   "dependencies": {
-    "@prisma-next/framework-components": "0.14.0-dev.6",
-    "@prisma-next/utils": "0.14.0-dev.6"
+    "@prisma-next/config": "0.14.0-dev.60",
+    "@prisma-next/framework-components": "0.14.0-dev.60",
+    "@prisma-next/utils": "0.14.0-dev.60"
   },
   "devDependencies": {
-    "@prisma-next/tsconfig": "0.14.0-dev.6",
-    "@prisma-next/tsdown": "0.14.0-dev.6",
+    "@prisma-next/tsconfig": "0.14.0-dev.60",
+    "@prisma-next/tsdown": "0.14.0-dev.60",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"
@@ -32,6 +33,7 @@
   "exports": {
     ".": "./dist/index.mjs",
     "./format": "./dist/format.mjs",
+    "./interpret": "./dist/interpret.mjs",
     "./syntax": "./dist/syntax.mjs",
     "./tokenizer": "./dist/tokenizer.mjs",
     "./package.json": "./package.json"

package/src/attribute-spec/combinators/bool.ts

@@ -0,0 +1,19 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { BooleanLiteralExprAst } from '../../syntax/ast/expressions';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export function bool(): ArgType<boolean> {
+  return {
+    kind: 'bool',
+    label: 'boolean',
+    parse: (arg, ctx): Result<boolean, readonly PslDiagnostic[]> => {
+      if (arg instanceof BooleanLiteralExprAst) {
+        const value = arg.value();
+        if (value !== undefined) return ok(value);
+      }
+      return notOk([leafDiagnostic(ctx, arg, 'Expected a boolean literal')]);
+    },
+  };
+}

package/src/attribute-spec/combinators/diagnostic.ts

@@ -0,0 +1,15 @@
+import type { PslDiagnostic, PslDiagnosticCode } from '@prisma-next/framework-components/psl-ast';
+import { nodePslSpan } from '../../resolve';
+import type { AstNode } from '../../syntax/ast-helpers';
+import type { InterpretCtx } from '../types';
+
+export const ATTRIBUTE_DIAGNOSTIC_CODE: PslDiagnosticCode = 'PSL_INVALID_ATTRIBUTE_SYNTAX';
+
+export function leafDiagnostic(ctx: InterpretCtx, node: AstNode, message: string): PslDiagnostic {
+  return {
+    code: ATTRIBUTE_DIAGNOSTIC_CODE,
+    message,
+    sourceId: ctx.sourceId,
+    span: nodePslSpan(node.syntax, ctx.sourceFile),
+  };
+}

package/src/attribute-spec/combinators/entity-ref.ts

@@ -0,0 +1,24 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { IdentifierAst } from '../../syntax/ast/identifier';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+// A bare model-name reference. Existence of a model with this name is resolved
+// downstream (e.g. `resolvePolymorphism`), not here.
+export function entityRef(): ArgType<string> {
+  return {
+    kind: 'entityRef',
+    label: 'model name',
+    parse: (arg, ctx): Result<string, readonly PslDiagnostic[]> => {
+      if (!(arg instanceof IdentifierAst)) {
+        return notOk([leafDiagnostic(ctx, arg, 'Expected a model name')]);
+      }
+      const name = arg.name();
+      if (name === undefined) {
+        return notOk([leafDiagnostic(ctx, arg, 'Expected a model name')]);
+      }
+      return ok(name);
+    },
+  };
+}

package/src/attribute-spec/combinators/field-ref.ts

@@ -0,0 +1,36 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { IdentifierAst } from '../../syntax/ast/identifier';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export type FieldRefScope = 'self' | 'referenced';
+
+export interface FieldRefArgType extends ArgType<string> {
+  readonly scope: FieldRefScope;
+}
+
+export function fieldRef(scope: FieldRefScope): FieldRefArgType {
+  return {
+    kind: 'fieldRef',
+    label: 'field name',
+    scope,
+    parse: (arg, ctx): Result<string, readonly PslDiagnostic[]> => {
+      if (!(arg instanceof IdentifierAst)) {
+        return notOk([leafDiagnostic(ctx, arg, 'Expected a field name')]);
+      }
+      const name = arg.name();
+      if (name === undefined) {
+        return notOk([leafDiagnostic(ctx, arg, 'Expected a field name')]);
+      }
+      const model = scope === 'self' ? ctx.selfModel : ctx.resolveReferencedModel();
+      // A referenced model in another space can't be resolved here (resolveReferencedModel returns undefined); skip the existence check — it runs where that model is known.
+      if (model !== undefined && !Object.hasOwn(model.fields, name)) {
+        return notOk([
+          leafDiagnostic(ctx, arg, `Field "${name}" does not exist on model "${model.name}"`),
+        ]);
+      }
+      return ok(name);
+    },
+  };
+}

package/src/attribute-spec/combinators/identifier.ts

@@ -0,0 +1,16 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { IdentifierAst } from '../../syntax/ast/identifier';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export function identifier<const N extends string>(name: N): ArgType<N> {
+  return {
+    kind: 'identifier',
+    label: name,
+    parse: (arg, ctx): Result<N, readonly PslDiagnostic[]> => {
+      if (arg instanceof IdentifierAst && arg.name() === name) return ok(name);
+      return notOk([leafDiagnostic(ctx, arg, `Expected ${name}`)]);
+    },
+  };
+}

package/src/attribute-spec/combinators/int.ts

@@ -0,0 +1,19 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { NumberLiteralExprAst } from '../../syntax/ast/expressions';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export function int(): ArgType<number> {
+  return {
+    kind: 'int',
+    label: 'integer',
+    parse: (arg, ctx): Result<number, readonly PslDiagnostic[]> => {
+      if (arg instanceof NumberLiteralExprAst) {
+        const value = arg.value();
+        if (value !== undefined && Number.isInteger(value)) return ok(value);
+      }
+      return notOk([leafDiagnostic(ctx, arg, 'Expected an integer literal')]);
+    },
+  };
+}

package/src/attribute-spec/combinators/list.ts

@@ -0,0 +1,43 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { ArrayLiteralAst, type ExpressionAst } from '../../syntax/ast/expressions';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export interface ListOptions {
+  readonly nonEmpty?: boolean;
+  readonly unique?: boolean;
+}
+
+export function list<T>(of: ArgType<T>, opts?: ListOptions): ArgType<T[]> {
+  return {
+    kind: 'list',
+    label: `${of.label}[]`,
+    parse: (arg, ctx): Result<T[], readonly PslDiagnostic[]> => {
+      if (!(arg instanceof ArrayLiteralAst)) {
+        return notOk([leafDiagnostic(ctx, arg, `Expected a list of ${of.label}`)]);
+      }
+      const diagnostics: PslDiagnostic[] = [];
+      const parsed: { node: ExpressionAst; value: T }[] = [];
+      let count = 0;
+      for (const element of arg.elements()) {
+        count += 1;
+        const result = of.parse(element, ctx);
+        if (result.ok) parsed.push({ node: element, value: result.value });
+        else diagnostics.push(...result.failure);
+      }
+      if (opts?.nonEmpty === true && count === 0) {
+        diagnostics.push(leafDiagnostic(ctx, arg, 'Expected a non-empty list'));
+      }
+      if (opts?.unique === true) {
+        const seen = new Set<T>();
+        for (const { node, value } of parsed) {
+          if (seen.has(value)) diagnostics.push(leafDiagnostic(ctx, node, 'Duplicate list entry'));
+          else seen.add(value);
+        }
+      }
+      if (diagnostics.length > 0) return notOk(diagnostics);
+      return ok(parsed.map((entry) => entry.value));
+    },
+  };
+}

package/src/attribute-spec/combinators/one-of.ts

@@ -0,0 +1,29 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { blindCast } from '@prisma-next/utils/casts';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import type { ArgType, OutOf } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export function oneOf<Alts extends readonly [ArgType<unknown>, ...ArgType<unknown>[]]>(
+  ...alts: Alts
+): ArgType<OutOf<Alts[number]>> {
+  const label = alts.map((alt) => alt.label).join(' | ');
+  return {
+    kind: 'oneOf',
+    label,
+    parse: (arg, ctx): Result<OutOf<Alts[number]>, readonly PslDiagnostic[]> => {
+      for (const alt of alts) {
+        const result = alt.parse(arg, ctx);
+        if (result.ok) {
+          return ok(
+            blindCast<
+              OutOf<Alts[number]>,
+              'The matched value comes from an alternative whose output type is a member of the union, but iterating the tuple widens each element to ArgType<unknown>, erasing that relationship.'
+            >(result.value),
+          );
+        }
+      }
+      return notOk([leafDiagnostic(ctx, arg, `Expected one of: ${label}`)]);
+    },
+  };
+}

package/src/attribute-spec/combinators/record.ts

@@ -0,0 +1,43 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { ObjectLiteralExprAst } from '../../syntax/ast/expressions';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export function record<T>(of: ArgType<T>): ArgType<Record<string, T>> {
+  return {
+    kind: 'record',
+    label: `{ [key]: ${of.label} }`,
+    parse: (arg, ctx): Result<Record<string, T>, readonly PslDiagnostic[]> => {
+      if (!(arg instanceof ObjectLiteralExprAst)) {
+        return notOk([leafDiagnostic(ctx, arg, 'Expected an object literal')]);
+      }
+      const diagnostics: PslDiagnostic[] = [];
+      const result: Record<string, T> = {};
+      for (const field of arg.fields()) {
+        const key = field.keyName();
+        if (key === undefined) {
+          diagnostics.push(leafDiagnostic(ctx, field, 'Expected a key'));
+          continue;
+        }
+        const value = field.value();
+        if (value === undefined) {
+          diagnostics.push(leafDiagnostic(ctx, field, `Expected a value for key "${key}"`));
+          continue;
+        }
+        const parsed = of.parse(value, ctx);
+        if (!parsed.ok) {
+          diagnostics.push(...parsed.failure);
+          continue;
+        }
+        if (Object.hasOwn(result, key)) {
+          diagnostics.push(leafDiagnostic(ctx, field, `Duplicate key "${key}"`));
+          continue;
+        }
+        result[key] = parsed.value;
+      }
+      if (diagnostics.length > 0) return notOk(diagnostics);
+      return ok(result);
+    },
+  };
+}

package/src/attribute-spec/combinators/str.ts

@@ -0,0 +1,19 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { StringLiteralExprAst } from '../../syntax/ast/expressions';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export function str(): ArgType<string> {
+  return {
+    kind: 'str',
+    label: 'string',
+    parse: (arg, ctx): Result<string, readonly PslDiagnostic[]> => {
+      if (arg instanceof StringLiteralExprAst) {
+        const value = arg.value();
+        if (value !== undefined) return ok(value);
+      }
+      return notOk([leafDiagnostic(ctx, arg, 'Expected a string literal')]);
+    },
+  };
+}

package/src/attribute-spec/field-attribute.ts

@@ -0,0 +1,27 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import type { AttributeOut, AttributeSpec, InterpretCtx, Param, PositionalParam } from './types';
+
+interface FieldAttributeConfig<
+  Pos extends readonly PositionalParam[],
+  Named extends Record<string, Param<unknown>>,
+> {
+  readonly positional?: Pos;
+  readonly named?: Named;
+  readonly refine?: (
+    parsed: AttributeOut<Pos, Named>,
+    ctx: InterpretCtx,
+  ) => readonly PslDiagnostic[];
+}
+
+export function fieldAttribute<
+  const Pos extends readonly PositionalParam[] = readonly [],
+  const Named extends Record<string, Param<unknown>> = Record<never, never>,
+>(name: string, config: FieldAttributeConfig<Pos, Named>): AttributeSpec<AttributeOut<Pos, Named>> {
+  return {
+    level: 'field',
+    name,
+    positional: config.positional ?? [],
+    named: config.named ?? {},
+    ...(config.refine !== undefined ? { refine: config.refine } : {}),
+  };
+}

package/src/attribute-spec/interpret.ts

@@ -0,0 +1,154 @@
+import type { PslDiagnostic, PslSpan } from '@prisma-next/framework-components/psl-ast';
+import { blindCast } from '@prisma-next/utils/casts';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { nodePslSpan } from '../resolve';
+import type { FieldAttributeAst, ModelAttributeAst } from '../syntax/ast/attributes';
+import type { AttributeArgAst } from '../syntax/ast/expressions';
+import { ATTRIBUTE_DIAGNOSTIC_CODE } from './combinators/diagnostic';
+import type { ArgType, AttributeSpec, InterpretCtx, OptionalArgType, Param } from './types';
+
+export function interpretAttribute<Out>(
+  attrNode: FieldAttributeAst | ModelAttributeAst,
+  spec: AttributeSpec<Out>,
+  ctx: InterpretCtx,
+): Result<Out, readonly PslDiagnostic[]> {
+  const diagnostics: PslDiagnostic[] = [];
+  const attributeSpan = nodePslSpan(attrNode.syntax, ctx.sourceFile);
+
+  const output: Record<string, unknown> = {};
+  const seen = new Set<string>();
+  let positionalSlot = 0;
+  let reportedExcess = false;
+
+  for (const arg of attrNode.argList()?.args() ?? []) {
+    const name = arg.name()?.name();
+
+    let key: string;
+    let param: Param<unknown>;
+    if (name === undefined) {
+      const posParam = spec.positional[positionalSlot];
+      if (posParam === undefined) {
+        if (!reportedExcess) {
+          diagnostics.push(
+            diagnostic(
+              `Attribute "${spec.name}" received too many positional arguments`,
+              ctx,
+              attributeSpan,
+            ),
+          );
+          reportedExcess = true;
+        }
+        continue;
+      }
+      positionalSlot += 1;
+      key = posParam.key;
+      param = posParam.type;
+    } else {
+      const namedParam = Object.hasOwn(spec.named, name) ? spec.named[name] : undefined;
+      if (namedParam === undefined) {
+        diagnostics.push(
+          diagnostic(
+            `Attribute "${spec.name}" received unknown argument "${name}"`,
+            ctx,
+            nodePslSpan(arg.syntax, ctx.sourceFile),
+          ),
+        );
+        continue;
+      }
+      key = name;
+      param = namedParam;
+    }
+
+    if (seen.has(key)) {
+      diagnostics.push(
+        diagnostic(
+          `Attribute "${spec.name}" received duplicate argument "${key}"`,
+          ctx,
+          nodePslSpan(arg.syntax, ctx.sourceFile),
+        ),
+      );
+      continue;
+    }
+    seen.add(key);
+    const result = parseArgValue(arg, param, ctx, diagnostics);
+    if (result.ok) output[key] = result.value;
+  }
+
+  const finalized = new Set<string>();
+  const finalizeAbsentKey = (
+    key: string,
+    positionalParam: Param<unknown> | undefined,
+    namedParam: Param<unknown> | undefined,
+  ): void => {
+    if (finalized.has(key) || seen.has(key)) return;
+    finalized.add(key);
+    const effective = namedParam ?? positionalParam;
+    if (effective === undefined) return;
+    if (isOptionalArgType(effective)) {
+      if (effective.hasDefault) output[key] = effective.defaultValue;
+      return;
+    }
+    diagnostics.push(
+      diagnostic(
+        `Attribute "${spec.name}" is missing required argument "${key}"`,
+        ctx,
+        attributeSpan,
+      ),
+    );
+  };
+
+  for (const param of spec.positional) {
+    const namedParam = Object.hasOwn(spec.named, param.key) ? spec.named[param.key] : undefined;
+    finalizeAbsentKey(param.key, param.type, namedParam);
+  }
+  for (const key of Object.keys(spec.named)) {
+    finalizeAbsentKey(key, undefined, spec.named[key]);
+  }
+
+  if (diagnostics.length > 0) {
+    return notOk<readonly PslDiagnostic[]>(diagnostics);
+  }
+
+  const value = blindCast<
+    Out,
+    'The engine builds the output object structurally from the spec; TypeScript cannot relate the dynamically-keyed record to the spec-inferred output type.'
+  >(output);
+  if (spec.refine !== undefined) {
+    const refineDiagnostics = spec.refine(value, ctx);
+    if (refineDiagnostics.length > 0) {
+      return notOk<readonly PslDiagnostic[]>(refineDiagnostics);
+    }
+  }
+  return ok(value);
+}
+
+function parseArgValue(
+  arg: AttributeArgAst,
+  argType: ArgType<unknown>,
+  ctx: InterpretCtx,
+  diagnostics: PslDiagnostic[],
+): Result<unknown, readonly PslDiagnostic[]> {
+  const value = arg.value();
+  if (value === undefined) {
+    const missing = diagnostic(
+      'Attribute argument is missing a value',
+      ctx,
+      nodePslSpan(arg.syntax, ctx.sourceFile),
+    );
+    diagnostics.push(missing);
+    return notOk<readonly PslDiagnostic[]>([missing]);
+  }
+  const result = argType.parse(value, ctx);
+  if (!result.ok) {
+    for (const failure of result.failure) diagnostics.push(failure);
+  }
+  return result;
+}
+
+function isOptionalArgType(param: Param<unknown>): param is OptionalArgType<unknown> {
+  return 'optional' in param && param.optional === true;
+}
+
+function diagnostic(message: string, ctx: InterpretCtx, span: PslSpan): PslDiagnostic {
+  return { code: ATTRIBUTE_DIAGNOSTIC_CODE, message, sourceId: ctx.sourceId, span };
+}

package/src/attribute-spec/model-attribute.ts

@@ -0,0 +1,27 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import type { AttributeOut, AttributeSpec, InterpretCtx, Param, PositionalParam } from './types';
+
+interface ModelAttributeConfig<
+  Pos extends readonly PositionalParam[],
+  Named extends Record<string, Param<unknown>>,
+> {
+  readonly positional?: Pos;
+  readonly named?: Named;
+  readonly refine?: (
+    parsed: AttributeOut<Pos, Named>,
+    ctx: InterpretCtx,
+  ) => readonly PslDiagnostic[];
+}
+
+export function modelAttribute<
+  const Pos extends readonly PositionalParam[] = readonly [],
+  const Named extends Record<string, Param<unknown>> = Record<never, never>,
+>(name: string, config: ModelAttributeConfig<Pos, Named>): AttributeSpec<AttributeOut<Pos, Named>> {
+  return {
+    level: 'model',
+    name,
+    positional: config.positional ?? [],
+    named: config.named ?? {},
+    ...(config.refine !== undefined ? { refine: config.refine } : {}),
+  };
+}

package/src/attribute-spec/optional.ts

@@ -0,0 +1,8 @@
+import type { ArgType, OptionalArgType } from './types';
+
+export function optional<T>(type: ArgType<T>, ...rest: [defaultValue: T] | []): OptionalArgType<T> {
+  if (rest.length === 0) {
+    return { ...type, optional: true, hasDefault: false };
+  }
+  return { ...type, optional: true, hasDefault: true, defaultValue: rest[0] };
+}

package/src/attribute-spec/types.ts

@@ -0,0 +1,72 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import type { Result } from '@prisma-next/utils/result';
+import type { Simplify, UnionToIntersection } from '@prisma-next/utils/types';
+import type { SourceFile } from '../source-file';
+import type { FieldSymbol, ModelSymbol } from '../symbol-table';
+import type { ExpressionAst } from '../syntax/ast/expressions';
+
+export type AttributeLevel = 'field' | 'model' | 'block';
+
+export interface ArgType<T> {
+  readonly kind: string;
+  readonly label: string;
+  // phantom carrier for `T`; never read at runtime.
+  readonly _out?: T;
+  parse(arg: ExpressionAst, ctx: InterpretCtx): Result<T, readonly PslDiagnostic[]>;
+}
+
+export interface InterpretCtx {
+  readonly level: AttributeLevel;
+  readonly sourceId: string;
+  readonly sourceFile: SourceFile;
+  readonly selfModel: ModelSymbol;
+  resolveReferencedModel(): ModelSymbol | undefined;
+  readonly field?: FieldSymbol;
+}
+
+export interface OptionalArgType<T> extends ArgType<T> {
+  // the engine detects optionality by checking for this marker (`'optional' in param`).
+  readonly optional: true;
+  readonly hasDefault: boolean;
+  readonly defaultValue?: T;
+}
+
+export type Param<T> = ArgType<T>;
+
+export interface PositionalParam<T = unknown> {
+  readonly key: string;
+  readonly type: Param<T>;
+}
+
+export interface AttributeSpec<Out> {
+  readonly level: AttributeLevel;
+  readonly name: string;
+  readonly positional: readonly PositionalParam[];
+  readonly named: Readonly<Record<string, Param<unknown>>>;
+  readonly refine?: (parsed: Out, ctx: InterpretCtx) => readonly PslDiagnostic[];
+}
+
+export type OutOf<P> = P extends ArgType<infer T> ? T : never;
+
+export type NamedOut<N extends Record<string, Param<unknown>>> = Simplify<
+  { [K in keyof N as N[K] extends OptionalArgType<unknown> ? never : K]: OutOf<N[K]> } & {
+    [K in keyof N as N[K] extends OptionalArgType<unknown> ? K : never]?: OutOf<N[K]>;
+  }
+>;
+
+type PosEntryObject<E extends PositionalParam> =
+  E['type'] extends OptionalArgType<unknown>
+    ? { [K in E['key']]?: OutOf<E['type']> }
+    : { [K in E['key']]: OutOf<E['type']> };
+
+export type PosOut<Pos extends readonly PositionalParam[]> = Simplify<
+  UnionToIntersection<{ [I in keyof Pos]: PosEntryObject<Pos[I]> }[number]>
+>;
+
+export type AttributeOut<
+  Pos extends readonly PositionalParam[],
+  Named extends Record<string, Param<unknown>>,
+> = Simplify<PosOut<Pos> & NamedOut<Named>>;
+
+// `S` is unconstrained on purpose: `refine` makes `Out` contravariant, so a bound like `S extends AttributeSpec<unknown>` would reject every spec that uses `refine`.
+export type InferAttr<S> = S extends AttributeSpec<infer Out> ? Out : never;

package/src/exports/index.ts

@@ -36,6 +36,36 @@ export {
   namespacePslExtensionBlocks,
 } from '@prisma-next/framework-components/psl-ast';
 export { getPositionalArgument, parseQuotedStringLiteral } from '../attribute-helpers';
+export { bool } from '../attribute-spec/combinators/bool';
+export { leafDiagnostic } from '../attribute-spec/combinators/diagnostic';
+export { entityRef } from '../attribute-spec/combinators/entity-ref';
+export type { FieldRefArgType, FieldRefScope } from '../attribute-spec/combinators/field-ref';
+export { fieldRef } from '../attribute-spec/combinators/field-ref';
+export { identifier } from '../attribute-spec/combinators/identifier';
+export { int } from '../attribute-spec/combinators/int';
+export type { ListOptions } from '../attribute-spec/combinators/list';
+export { list } from '../attribute-spec/combinators/list';
+export { oneOf } from '../attribute-spec/combinators/one-of';
+export { record } from '../attribute-spec/combinators/record';
+export { str } from '../attribute-spec/combinators/str';
+export { fieldAttribute } from '../attribute-spec/field-attribute';
+export { interpretAttribute } from '../attribute-spec/interpret';
+export { modelAttribute } from '../attribute-spec/model-attribute';
+export { optional } from '../attribute-spec/optional';
+export type {
+  ArgType,
+  AttributeLevel,
+  AttributeOut,
+  AttributeSpec,
+  InferAttr,
+  InterpretCtx,
+  NamedOut,
+  OptionalArgType,
+  OutOf,
+  Param,
+  PositionalParam,
+  PosOut,
+} from '../attribute-spec/types';
 export { findBlockDescriptor, validateExtensionBlockFromSymbol } from '../extension-block';
 export {
   keywordPslSpan,

package/src/exports/interpret.ts

@@ -0,0 +1,2 @@
+export type { PslInterpretCapable, PslInterpretInput } from '../interpret';
+export { hasPslInterpreter } from '../interpret';