@prisma-next/sql-contract-psl 0.5.0-dev.9 → 0.6.0-dev.1

package/src/interpreter.ts

@@ -35,17 +35,21 @@ import {
   type ForeignKeyNode,
   type IndexNode,
   type ModelNode,
+  type PrimaryKeyNode,
   type UniqueConstraintNode,
 } from '@prisma-next/sql-contract-ts/contract-builder';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import {
+  findDuplicateFieldName,
   getAttribute,
+  getNamedArgument,
   getPositionalArgument,
   mapFieldNamesToColumns,
   parseAttributeFieldList,
   parseConstraintMapArgument,
   parseMapName,
+  parseObjectLiteralStringMap,
   parseQuotedStringLiteral,
 } from './psl-attribute-parsing';
 import type { ColumnDescriptor } from './psl-column-resolution';
@@ -77,19 +81,19 @@ import {
 
 export interface InterpretPslDocumentToSqlContractInput {
   readonly document: ParsePslDocumentResult;
-  readonly target: TargetPackRef<'sql', 'postgres'>;
+  readonly target: TargetPackRef<'sql', string>;
   readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
   readonly composedExtensionPacks?: readonly string[];
-  readonly composedExtensionPackRefs?: readonly ExtensionPackRef<'sql', 'postgres'>[];
+  readonly composedExtensionPackRefs?: readonly ExtensionPackRef<'sql', string>[];
   readonly controlMutationDefaults?: ControlMutationDefaults;
   readonly authoringContributions?: AuthoringContributions;
 }
 
 function buildComposedExtensionPackRefs(
-  target: TargetPackRef<'sql', 'postgres'>,
+  target: TargetPackRef<'sql', string>,
   extensionIds: readonly string[],
-  extensionPackRefs: readonly ExtensionPackRef<'sql', 'postgres'>[] = [],
-): Record<string, ExtensionPackRef<'sql', 'postgres'>> | undefined {
+  extensionPackRefs: readonly ExtensionPackRef<'sql', string>[] = [],
+): Record<string, ExtensionPackRef<'sql', string>> | undefined {
   if (extensionIds.length === 0) {
     return undefined;
   }
@@ -106,7 +110,7 @@ function buildComposedExtensionPackRefs(
           familyId: target.familyId,
           targetId: target.targetId,
           version: '0.0.1',
-        } satisfies ExtensionPackRef<'sql', 'postgres'>),
+        } satisfies ExtensionPackRef<'sql', string>),
     ]),
   );
 }
@@ -219,6 +223,7 @@ function validateNamedTypeAttributes(input: {
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly composedExtensions: ReadonlySet<string>;
+  readonly authoringContributions: AuthoringContributions | undefined;
   readonly allowDbNativeType: boolean;
   readonly familyId: string;
   readonly targetId: string;
@@ -250,6 +255,7 @@ function validateNamedTypeAttributes(input: {
     const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
       familyId: input.familyId,
       targetId: input.targetId,
+      authoringContributions: input.authoringContributions,
     });
     if (uncomposedNamespace) {
       reportUncomposedNamespace({
@@ -289,6 +295,7 @@ function resolveNamedTypeDeclarations(input: ResolveNamedTypeDeclarationsInput):
         sourceId: input.sourceId,
         diagnostics: input.diagnostics,
         composedExtensions: input.composedExtensions,
+        authoringContributions: input.authoringContributions,
         allowDbNativeType: false,
         familyId: input.familyId,
         targetId: input.targetId,
@@ -367,6 +374,7 @@ function resolveNamedTypeDeclarations(input: ResolveNamedTypeDeclarationsInput):
         sourceId: input.sourceId,
         diagnostics: input.diagnostics,
         composedExtensions: input.composedExtensions,
+        authoringContributions: input.authoringContributions,
         allowDbNativeType: true,
         familyId: input.familyId,
         targetId: input.targetId,
@@ -460,18 +468,24 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
     scalarTypeDescriptors: input.scalarTypeDescriptors,
   });
 
-  const primaryKeyFields = resolvedFields.filter((field) => field.isId);
-  const primaryKeyColumns = primaryKeyFields.map((field) => field.columnName);
-  const primaryKeyName = primaryKeyFields.length === 1 ? primaryKeyFields[0]?.idName : undefined;
-  const isVariantModel = model.attributes.some((attr) => attr.name === 'base');
-  if (primaryKeyColumns.length === 0 && !isVariantModel) {
+  const inlineIdFields = resolvedFields.filter((field) => field.isId);
+  if (inlineIdFields.length > 1) {
     diagnostics.push({
-      code: 'PSL_MISSING_PRIMARY_KEY',
-      message: `Model "${model.name}" must declare at least one @id field for SQL provider`,
+      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+      message: `Model "${model.name}" cannot declare inline @id on multiple fields; use model-level @@id([...]) for composite identity`,
       sourceId,
       span: model.span,
     });
   }
+  const singleInlineIdField = inlineIdFields.length === 1 ? inlineIdFields[0] : undefined;
+  let primaryKey: PrimaryKeyNode | undefined = singleInlineIdField
+    ? {
+        columns: [singleInlineIdField.columnName],
+        ...ifDefined('name', singleInlineIdField.idName),
+      }
+    : undefined;
+  const hasInlinePrimaryKey = primaryKey !== undefined;
+  let blockPrimaryKeyDeclared = false;
 
   const resultBackrelationCandidates: ModelBackrelationCandidate[] = [];
   for (const field of model.fields) {
@@ -483,6 +497,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
       field,
       sourceId,
       composedExtensions: input.composedExtensions,
+      authoringContributions: input.authoringContributions,
       diagnostics,
       familyId: input.familyId,
       targetId: input.targetId,
@@ -557,17 +572,107 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
     if (modelAttribute.name === 'discriminator' || modelAttribute.name === 'base') {
       continue;
     }
+    const attributeLabel = `Model "${model.name}" @@${modelAttribute.name}`;
+    if (modelAttribute.name === 'id') {
+      if (blockPrimaryKeyDeclared) {
+        diagnostics.push({
+          code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+          message: `Model "${model.name}" declares @@id more than once`,
+          sourceId,
+          span: modelAttribute.span,
+        });
+        continue;
+      }
+      if (hasInlinePrimaryKey) {
+        diagnostics.push({
+          code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+          message: `Model "${model.name}" cannot declare both field-level @id and model-level @@id`,
+          sourceId,
+          span: modelAttribute.span,
+        });
+        blockPrimaryKeyDeclared = true;
+        continue;
+      }
+      const fieldNames = parseAttributeFieldList({
+        attribute: modelAttribute,
+        sourceId,
+        diagnostics,
+        code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+        entityLabel: attributeLabel,
+      });
+      if (!fieldNames) {
+        continue;
+      }
+      const duplicateFieldName = findDuplicateFieldName(fieldNames);
+      if (duplicateFieldName !== undefined) {
+        diagnostics.push({
+          code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+          message: `${attributeLabel} list contains duplicate field "${duplicateFieldName}"`,
+          sourceId,
+          span: modelAttribute.span,
+        });
+        continue;
+      }
+      const nullableFieldName = fieldNames.find(
+        (name) => model.fields.find((f) => f.name === name)?.optional === true,
+      );
+      if (nullableFieldName !== undefined) {
+        diagnostics.push({
+          code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+          message: `${attributeLabel} cannot include optional field "${nullableFieldName}"; primary key columns must be NOT NULL`,
+          sourceId,
+          span: modelAttribute.span,
+        });
+        continue;
+      }
+      const columnNames = mapFieldNamesToColumns({
+        modelName: model.name,
+        fieldNames,
+        mapping,
+        sourceId,
+        diagnostics,
+        span: modelAttribute.span,
+        entityLabel: attributeLabel,
+      });
+      if (!columnNames) {
+        continue;
+      }
+      const constraintName = parseConstraintMapArgument({
+        attribute: modelAttribute,
+        sourceId,
+        diagnostics,
+        entityLabel: attributeLabel,
+        span: modelAttribute.span,
+        code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+      });
+      primaryKey = {
+        columns: columnNames,
+        ...ifDefined('name', constraintName),
+      };
+      blockPrimaryKeyDeclared = true;
+      continue;
+    }
     if (modelAttribute.name === 'unique' || modelAttribute.name === 'index') {
       const fieldNames = parseAttributeFieldList({
         attribute: modelAttribute,
         sourceId,
         diagnostics,
         code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-        messagePrefix: `Model "${model.name}" @@${modelAttribute.name}`,
+        entityLabel: attributeLabel,
       });
       if (!fieldNames) {
         continue;
       }
+      const duplicateFieldName = findDuplicateFieldName(fieldNames);
+      if (duplicateFieldName !== undefined) {
+        diagnostics.push({
+          code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+          message: `${attributeLabel} list contains duplicate field "${duplicateFieldName}"`,
+          sourceId,
+          span: modelAttribute.span,
+        });
+        continue;
+      }
       const columnNames = mapFieldNamesToColumns({
         modelName: model.name,
         fieldNames,
@@ -575,7 +680,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
         sourceId,
         diagnostics,
         span: modelAttribute.span,
-        contextLabel: `Model "${model.name}" @@${modelAttribute.name}`,
+        entityLabel: attributeLabel,
       });
       if (!columnNames) {
         continue;
@@ -584,7 +689,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
         attribute: modelAttribute,
         sourceId,
         diagnostics,
-        entityLabel: `Model "${model.name}" @@${modelAttribute.name}`,
+        entityLabel: attributeLabel,
         span: modelAttribute.span,
         code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
       });
@@ -594,9 +699,51 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
           ...ifDefined('name', constraintName),
         });
       } else {
+        const indexEntityLabel = `Model "${model.name}" @@index`;
+        const rawTypeArg = getNamedArgument(modelAttribute, 'type');
+        let indexType: string | undefined;
+        if (rawTypeArg !== undefined) {
+          const parsed = parseQuotedStringLiteral(rawTypeArg);
+          if (parsed === undefined) {
+            diagnostics.push({
+              code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+              message: `${indexEntityLabel} type argument must be a quoted string literal`,
+              sourceId,
+              span: modelAttribute.span,
+            });
+            continue;
+          }
+          indexType = parsed;
+        }
+        const rawOptionsArg = getNamedArgument(modelAttribute, 'options');
+        let indexOptions: Record<string, string> | undefined;
+        if (rawOptionsArg !== undefined) {
+          if (indexType === undefined) {
+            diagnostics.push({
+              code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+              message: `${indexEntityLabel} options argument requires a type argument`,
+              sourceId,
+              span: modelAttribute.span,
+            });
+            continue;
+          }
+          const parsed = parseObjectLiteralStringMap({
+            raw: rawOptionsArg,
+            diagnostics,
+            sourceId,
+            span: modelAttribute.span,
+            entityLabel: indexEntityLabel,
+          });
+          if (parsed === undefined) {
+            continue;
+          }
+          indexOptions = parsed;
+        }
         indexNodes.push({
           columns: columnNames,
           ...ifDefined('name', constraintName),
+          ...ifDefined('type', indexType),
+          ...ifDefined('options', indexOptions),
         });
       }
       continue;
@@ -604,7 +751,11 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
     const uncomposedNamespace = checkUncomposedNamespace(
       modelAttribute.name,
       input.composedExtensions,
-      { familyId: input.familyId, targetId: input.targetId },
+      {
+        familyId: input.familyId,
+        targetId: input.targetId,
+        authoringContributions: input.authoringContributions,
+      },
     );
     if (uncomposedNamespace) {
       reportUncomposedNamespace({
@@ -678,7 +829,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
       sourceId,
       diagnostics,
       span: relationAttribute.relation.span,
-      contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`,
+      entityLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`,
     });
     if (!localColumns) {
       continue;
@@ -690,7 +841,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
       sourceId,
       diagnostics,
       span: relationAttribute.relation.span,
-      contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`,
+      entityLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`,
     });
     if (!referencedColumns) {
       continue;
@@ -762,16 +913,9 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
         descriptor: resolvedField.descriptor,
         nullable: resolvedField.field.optional,
         ...ifDefined('default', resolvedField.defaultValue),
-        ...ifDefined('executionDefault', resolvedField.executionDefault),
+        ...ifDefined('executionDefaults', resolvedField.executionDefaults),
       })),
-      ...(primaryKeyColumns.length > 0
-        ? {
-            id: {
-              columns: primaryKeyColumns,
-              ...ifDefined('name', primaryKeyName),
-            },
-          }
-        : {}),
+      ...ifDefined('id', primaryKey),
       ...(uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {}),
       ...(indexNodes.length > 0 ? { indexes: indexNodes } : {}),
       ...(foreignKeyNodes.length > 0 ? { foreignKeys: foreignKeyNodes } : {}),

package/src/provider.ts

@@ -10,8 +10,8 @@ import type { ColumnDescriptor } from './psl-column-resolution';
 
 export interface PrismaContractOptions {
   readonly output?: string;
-  readonly target: TargetPackRef<'sql', 'postgres'>;
-  readonly composedExtensionPackRefs?: readonly ExtensionPackRef<'sql', 'postgres'>[];
+  readonly target: TargetPackRef<'sql', string>;
+  readonly composedExtensionPackRefs?: readonly ExtensionPackRef<'sql', string>[];
 }
 
 function buildColumnDescriptorMap(
@@ -20,9 +20,7 @@ function buildColumnDescriptorMap(
 ): ReadonlyMap<string, ColumnDescriptor> {
   const result = new Map<string, ColumnDescriptor>();
   for (const [typeName, codecId] of scalarTypeDescriptors) {
-    const codec = codecLookup.get(codecId);
-    if (!codec) continue;
-    const nativeType = codec.targetTypes[0];
+    const nativeType = codecLookup.targetTypesFor(codecId)?.[0];
     if (nativeType === undefined) continue;
     result.set(typeName, { codecId, nativeType });
   }

package/src/psl-attribute-parsing.ts

@@ -133,6 +133,132 @@ export function getPositionalArguments(attribute: PslAttribute): readonly string
     .map((arg) => (arg.kind === 'positional' ? arg.value : ''));
 }
 
+/**
+ * Parses a PSL object-literal attribute argument value of the form
+ * `{ key1: "value1", key2: "value2" }` into a `Record<string, string>`.
+ *
+ * V1 admits string literals only as leaf values. Boolean and number
+ * literals are rejected. Trailing commas are allowed.
+ *
+ * Returns the parsed record, or pushes a diagnostic and returns undefined
+ * on malformed input or non-string leaves.
+ */
+export function parseObjectLiteralStringMap(input: {
+  readonly raw: string;
+  readonly diagnostics: ContractSourceDiagnostic[];
+  readonly sourceId: string;
+  readonly span: PslSpan;
+  readonly entityLabel: string;
+}): Record<string, string> | undefined {
+  const trimmed = input.raw.trim();
+  if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+    return pushInvalidAttributeArgument({
+      diagnostics: input.diagnostics,
+      sourceId: input.sourceId,
+      span: input.span,
+      message: `${input.entityLabel} expected an object literal value of the form { key: "value", ... }`,
+    });
+  }
+  const body = trimmed.slice(1, -1).trim();
+  if (body.length === 0) {
+    return {};
+  }
+  const result: Record<string, string> = {};
+  for (const part of splitObjectLiteralEntries(body)) {
+    const colonAt = findTopLevelColon(part);
+    if (colonAt === -1) {
+      return pushInvalidAttributeArgument({
+        diagnostics: input.diagnostics,
+        sourceId: input.sourceId,
+        span: input.span,
+        message: `${input.entityLabel} object-literal entry "${part}" is missing a "key: value" colon`,
+      });
+    }
+    const key = part.slice(0, colonAt).trim();
+    const rawValue = part.slice(colonAt + 1).trim();
+    if (key.length === 0 || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      return pushInvalidAttributeArgument({
+        diagnostics: input.diagnostics,
+        sourceId: input.sourceId,
+        span: input.span,
+        message: `${input.entityLabel} object-literal key "${key}" must be a bare identifier`,
+      });
+    }
+    const parsedString = parseQuotedStringLiteral(rawValue);
+    if (parsedString === undefined) {
+      return pushInvalidAttributeArgument({
+        diagnostics: input.diagnostics,
+        sourceId: input.sourceId,
+        span: input.span,
+        message: `${input.entityLabel} object-literal value for "${key}" must be a quoted string literal (V1 PSL @@index options support string leaves only; use the TS authoring surface for non-string options)`,
+      });
+    }
+    if (Object.hasOwn(result, key)) {
+      return pushInvalidAttributeArgument({
+        diagnostics: input.diagnostics,
+        sourceId: input.sourceId,
+        span: input.span,
+        message: `${input.entityLabel} object-literal key "${key}" appears more than once`,
+      });
+    }
+    result[key] = parsedString;
+  }
+  return result;
+}
+
+function splitObjectLiteralEntries(body: string): readonly string[] {
+  const parts: string[] = [];
+  let depthBrace = 0;
+  let depthBracket = 0;
+  let depthParen = 0;
+  let quote: '"' | "'" | null = null;
+  let start = 0;
+  for (let index = 0; index < body.length; index += 1) {
+    const ch = body[index] ?? '';
+    if (quote) {
+      if (ch === quote && body[index - 1] !== '\\') {
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === '{') depthBrace += 1;
+    else if (ch === '}') depthBrace = Math.max(0, depthBrace - 1);
+    else if (ch === '[') depthBracket += 1;
+    else if (ch === ']') depthBracket = Math.max(0, depthBracket - 1);
+    else if (ch === '(') depthParen += 1;
+    else if (ch === ')') depthParen = Math.max(0, depthParen - 1);
+    else if (ch === ',' && depthBrace === 0 && depthBracket === 0 && depthParen === 0) {
+      const segment = body.slice(start, index).trim();
+      if (segment.length > 0) parts.push(segment);
+      start = index + 1;
+    }
+  }
+  const tail = body.slice(start).trim();
+  if (tail.length > 0) parts.push(tail);
+  return parts;
+}
+
+function findTopLevelColon(entry: string): number {
+  let quote: '"' | "'" | null = null;
+  for (let index = 0; index < entry.length; index += 1) {
+    const ch = entry[index] ?? '';
+    if (quote) {
+      if (ch === quote && entry[index - 1] !== '\\') quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === ':') return index;
+  }
+  return -1;
+}
+
 export function pushInvalidAttributeArgument(input: {
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
@@ -251,13 +377,13 @@ export function parseAttributeFieldList(input: {
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly code: string;
-  readonly messagePrefix: string;
+  readonly entityLabel: string;
 }): readonly string[] | undefined {
   const raw = getNamedArgument(input.attribute, 'fields') ?? getPositionalArgument(input.attribute);
   if (!raw) {
     input.diagnostics.push({
       code: input.code,
-      message: `${input.messagePrefix} requires fields list argument`,
+      message: `${input.entityLabel} requires fields list argument`,
       sourceId: input.sourceId,
       span: input.attribute.span,
     });
@@ -267,7 +393,7 @@ export function parseAttributeFieldList(input: {
   if (!fields || fields.length === 0) {
     input.diagnostics.push({
       code: input.code,
-      message: `${input.messagePrefix} requires bracketed field list argument`,
+      message: `${input.entityLabel} requires bracketed field list argument`,
       sourceId: input.sourceId,
       span: input.attribute.span,
     });
@@ -276,6 +402,15 @@ export function parseAttributeFieldList(input: {
   return fields;
 }
 
+export function findDuplicateFieldName(fieldNames: readonly string[]): string | undefined {
+  const seen = new Set<string>();
+  for (const name of fieldNames) {
+    if (seen.has(name)) return name;
+    seen.add(name);
+  }
+  return undefined;
+}
+
 export function mapFieldNamesToColumns(input: {
   readonly modelName: string;
   readonly fieldNames: readonly string[];
@@ -283,7 +418,7 @@ export function mapFieldNamesToColumns(input: {
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly span: PslSpan;
-  readonly contextLabel: string;
+  readonly entityLabel: string;
 }): readonly string[] | undefined {
   const columns: string[] = [];
   for (const fieldName of input.fieldNames) {
@@ -291,7 +426,7 @@ export function mapFieldNamesToColumns(input: {
     if (!columnName) {
       input.diagnostics.push({
         code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-        message: `${input.contextLabel} references unknown field "${input.modelName}.${fieldName}"`,
+        message: `${input.entityLabel} references unknown field "${input.modelName}.${fieldName}"`,
         sourceId: input.sourceId,
         span: input.span,
       });

package/src/psl-authoring-arguments.ts

@@ -311,6 +311,12 @@ function parsePslAuthoringArgumentValue(
   switch (descriptor.kind) {
     case 'string':
       return unquoteStringLiteral(rawValue);
+    case 'boolean': {
+      const trimmed = rawValue.trim();
+      if (trimmed === 'true') return true;
+      if (trimmed === 'false') return false;
+      return INVALID_AUTHORING_ARGUMENT;
+    }
     case 'number': {
       const parsed = Number(unquoteStringLiteral(rawValue));
       return Number.isNaN(parsed) ? INVALID_AUTHORING_ARGUMENT : parsed;