@prisma-next/sql-contract-psl 0.14.0-dev.5 → 0.14.0-dev.6

package/src/psl-named-type-resolution.ts

@@ -0,0 +1,250 @@
+import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
+import type { AuthoringContributions } from '@prisma-next/framework-components/authoring';
+import type { ResolvedAttribute, ScalarSymbol, TypeAliasSymbol } from '@prisma-next/psl-parser';
+import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import {
+  type ColumnDescriptor,
+  checkUncomposedNamespace,
+  instantiatePslTypeConstructor,
+  reportUncomposedNamespace,
+  resolveDbNativeTypeAttribute,
+  resolvePslTypeConstructorDescriptor,
+  toNamedTypeFieldDescriptor,
+} from './psl-column-resolution';
+
+type NamedTypeSymbol = ScalarSymbol | TypeAliasSymbol;
+
+export interface ResolveNamedTypeDeclarationsInput {
+  readonly declarations: readonly NamedTypeSymbol[];
+  readonly sourceId: string;
+  readonly enumTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly composedExtensions: ReadonlySet<string>;
+  readonly familyId: string;
+  readonly targetId: string;
+  readonly authoringContributions: AuthoringContributions | undefined;
+  readonly diagnostics: ContractSourceDiagnostic[];
+}
+
+function validateNamedTypeAttributes(input: {
+  readonly declaration: NamedTypeSymbol;
+  readonly sourceId: string;
+  readonly diagnostics: ContractSourceDiagnostic[];
+  readonly composedExtensions: ReadonlySet<string>;
+  readonly authoringContributions: AuthoringContributions | undefined;
+  readonly allowDbNativeType: boolean;
+  readonly familyId: string;
+  readonly targetId: string;
+}): {
+  readonly dbNativeTypeAttribute: ResolvedAttribute | undefined;
+  readonly hasUnsupportedNamedTypeAttribute: boolean;
+} {
+  const dbNativeTypeAttributes = input.allowDbNativeType
+    ? input.declaration.attributes.filter((attribute) => attribute.name.startsWith('db.'))
+    : [];
+  const [dbNativeTypeAttribute, ...extraDbNativeTypeAttributes] = dbNativeTypeAttributes;
+  let hasUnsupportedNamedTypeAttribute = false;
+
+  for (const extra of extraDbNativeTypeAttributes) {
+    input.diagnostics.push({
+      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+      message: `Named type "${input.declaration.name}" can declare at most one @db.* attribute`,
+      sourceId: input.sourceId,
+      span: extra.span,
+    });
+    hasUnsupportedNamedTypeAttribute = true;
+  }
+
+  for (const attribute of input.declaration.attributes) {
+    if (input.allowDbNativeType && attribute.name.startsWith('db.')) {
+      continue;
+    }
+
+    const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
+      familyId: input.familyId,
+      targetId: input.targetId,
+      authoringContributions: input.authoringContributions,
+    });
+    if (uncomposedNamespace) {
+      reportUncomposedNamespace({
+        subjectLabel: `Attribute "@${attribute.name}"`,
+        namespace: uncomposedNamespace,
+        sourceId: input.sourceId,
+        span: attribute.span,
+        diagnostics: input.diagnostics,
+      });
+      hasUnsupportedNamedTypeAttribute = true;
+      continue;
+    }
+
+    input.diagnostics.push({
+      code: 'PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE',
+      message: `Named type "${input.declaration.name}" uses unsupported attribute "${attribute.name}"`,
+      sourceId: input.sourceId,
+      span: attribute.span,
+    });
+    hasUnsupportedNamedTypeAttribute = true;
+  }
+
+  return { dbNativeTypeAttribute, hasUnsupportedNamedTypeAttribute };
+}
+
+export function resolveNamedTypeDeclarations(input: ResolveNamedTypeDeclarationsInput): {
+  readonly storageTypes: Record<string, StorageTypeInstance>;
+  readonly namedTypeDescriptors: Map<string, ColumnDescriptor>;
+} {
+  const storageTypeEntries: [string, StorageTypeInstance][] = [];
+  const namedTypeDescriptors = new Map<string, ColumnDescriptor>();
+
+  for (const declaration of input.declarations) {
+    if (declaration.isConstructor) {
+      const typeConstructor = declaration.typeConstructor;
+      if (typeConstructor === undefined) {
+        input.diagnostics.push({
+          code: 'PSL_UNSUPPORTED_NAMED_TYPE_BASE',
+          message: `Named type "${declaration.name}" must declare a base type or constructor`,
+          sourceId: input.sourceId,
+          span: declaration.span,
+        });
+        continue;
+      }
+
+      const { hasUnsupportedNamedTypeAttribute } = validateNamedTypeAttributes({
+        declaration,
+        sourceId: input.sourceId,
+        diagnostics: input.diagnostics,
+        composedExtensions: input.composedExtensions,
+        authoringContributions: input.authoringContributions,
+        allowDbNativeType: false,
+        familyId: input.familyId,
+        targetId: input.targetId,
+      });
+      if (hasUnsupportedNamedTypeAttribute) {
+        continue;
+      }
+
+      const helperPath = typeConstructor.path.join('.');
+      const descriptor = resolvePslTypeConstructorDescriptor({
+        call: typeConstructor,
+        authoringContributions: input.authoringContributions,
+        composedExtensions: input.composedExtensions,
+        familyId: input.familyId,
+        targetId: input.targetId,
+        diagnostics: input.diagnostics,
+        sourceId: input.sourceId,
+        unsupportedCode: 'PSL_UNSUPPORTED_NAMED_TYPE_CONSTRUCTOR',
+        unsupportedMessage: `Named type "${declaration.name}" references unsupported constructor "${helperPath}"`,
+      });
+      if (!descriptor) {
+        continue;
+      }
+
+      const storageType = instantiatePslTypeConstructor({
+        call: typeConstructor,
+        descriptor,
+        diagnostics: input.diagnostics,
+        sourceId: input.sourceId,
+        entityLabel: `Named type "${declaration.name}"`,
+      });
+      if (!storageType) {
+        continue;
+      }
+
+      namedTypeDescriptors.set(
+        declaration.name,
+        toNamedTypeFieldDescriptor(declaration.name, storageType),
+      );
+      storageTypeEntries.push([
+        declaration.name,
+        {
+          kind: 'codec-instance',
+          codecId: storageType.codecId,
+          nativeType: storageType.nativeType,
+          typeParams: storageType.typeParams ?? {},
+        },
+      ]);
+      continue;
+    }
+
+    const baseType = declaration.baseType;
+    if (baseType === undefined) {
+      input.diagnostics.push({
+        code: 'PSL_UNSUPPORTED_NAMED_TYPE_BASE',
+        message: `Named type "${declaration.name}" must declare a base type or constructor`,
+        sourceId: input.sourceId,
+        span: declaration.span,
+      });
+      continue;
+    }
+
+    const baseDescriptor =
+      input.enumTypeDescriptors.get(baseType) ?? input.scalarTypeDescriptors.get(baseType);
+    if (!baseDescriptor) {
+      input.diagnostics.push({
+        code: 'PSL_UNSUPPORTED_NAMED_TYPE_BASE',
+        message: `Named type "${declaration.name}" references unsupported base type "${baseType}"`,
+        sourceId: input.sourceId,
+        span: declaration.span,
+      });
+      continue;
+    }
+
+    const { dbNativeTypeAttribute, hasUnsupportedNamedTypeAttribute } = validateNamedTypeAttributes(
+      {
+        declaration,
+        sourceId: input.sourceId,
+        diagnostics: input.diagnostics,
+        composedExtensions: input.composedExtensions,
+        authoringContributions: input.authoringContributions,
+        allowDbNativeType: true,
+        familyId: input.familyId,
+        targetId: input.targetId,
+      },
+    );
+    if (hasUnsupportedNamedTypeAttribute) {
+      continue;
+    }
+
+    if (dbNativeTypeAttribute) {
+      const descriptor = resolveDbNativeTypeAttribute({
+        attribute: dbNativeTypeAttribute,
+        baseType,
+        baseDescriptor,
+        diagnostics: input.diagnostics,
+        sourceId: input.sourceId,
+        entityLabel: `Named type "${declaration.name}"`,
+      });
+      if (!descriptor) {
+        continue;
+      }
+      namedTypeDescriptors.set(
+        declaration.name,
+        toNamedTypeFieldDescriptor(declaration.name, descriptor),
+      );
+      storageTypeEntries.push([
+        declaration.name,
+        {
+          kind: 'codec-instance',
+          codecId: descriptor.codecId,
+          nativeType: descriptor.nativeType,
+          typeParams: descriptor.typeParams ?? {},
+        },
+      ]);
+      continue;
+    }
+
+    const descriptor = toNamedTypeFieldDescriptor(declaration.name, baseDescriptor);
+    namedTypeDescriptors.set(declaration.name, descriptor);
+    storageTypeEntries.push([
+      declaration.name,
+      {
+        kind: 'codec-instance',
+        codecId: baseDescriptor.codecId,
+        nativeType: baseDescriptor.nativeType,
+        typeParams: {},
+      },
+    ]);
+  }
+
+  return { storageTypes: Object.fromEntries(storageTypeEntries), namedTypeDescriptors };
+}

package/src/psl-relation-resolution.ts

@@ -1,10 +1,11 @@
 import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
 import type { AuthoringContributions } from '@prisma-next/framework-components/authoring';
-import type { PslAttribute, PslField, PslSpan } from '@prisma-next/psl-parser';
+import type { FieldSymbol, PslSpan, ResolvedAttribute } from '@prisma-next/psl-parser';
 import type { ReferentialAction } from '@prisma-next/sql-contract/types';
 import type { RelationNode } from '@prisma-next/sql-contract-ts/contract-builder';
 import { assertDefined, invariant } from '@prisma-next/utils/assertions';
 import { ifDefined } from '@prisma-next/utils/defined';
+
 import {
   getNamedArgument,
   getPositionalArgumentEntry,
@@ -52,7 +53,7 @@ export type FkRelationMetadata = {
 export type ModelBackrelationCandidate = {
   readonly modelName: string;
   readonly tableName: string;
-  readonly field: PslField;
+  readonly field: FieldSymbol;
   readonly targetModelName: string;
   readonly relationName?: string;
 };
@@ -88,7 +89,7 @@ export function normalizeReferentialAction(input: {
 }
 
 export function parseRelationAttribute(input: {
-  readonly attribute: PslAttribute;
+  readonly attribute: ResolvedAttribute;
   readonly modelName: string;
   readonly fieldName: string;
   readonly sourceId: string;
@@ -334,7 +335,7 @@ export function applyBackrelationCandidates(input: {
 
 export function validateNavigationListFieldAttributes(input: {
   readonly modelName: string;
-  readonly field: PslField;
+  readonly field: FieldSymbol;
   readonly sourceId: string;
   readonly composedExtensions: Set<string>;
   readonly authoringContributions: AuthoringContributions | undefined;