@prisma-next/sql-contract-psl 0.13.0 → 0.14.0-dev.10

package/src/provider.ts

@@ -1,15 +1,18 @@
 import { readFile } from 'node:fs/promises';
-import type { ContractConfig } from '@prisma-next/config/config-types';
+import type { ContractConfig, ContractSourceDiagnostic } from '@prisma-next/config/config-types';
 import { applySpecifierDefaultControlPolicy } from '@prisma-next/contract/apply-specifier-default-control-policy';
 import type { ControlPolicy } from '@prisma-next/contract/types';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
 import type { Namespace } from '@prisma-next/framework-components/ir';
-import { parsePslDocument } from '@prisma-next/psl-parser';
+import { buildSymbolTable, rangeToPslSpan } from '@prisma-next/psl-parser';
+import type { ParseDiagnostic, SourceFile } from '@prisma-next/psl-parser/syntax';
+import { parse } from '@prisma-next/psl-parser/syntax';
 import type { SqlNamespaceTablesInput } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok } from '@prisma-next/utils/result';
 import { basename, extname } from 'pathe';
+
 import { interpretPslDocumentToSqlContract } from './interpreter';
 import type { ColumnDescriptor } from './psl-column-resolution';
 
@@ -42,6 +45,19 @@ function defaultOutputFromSchemaPath(schemaPath: string): string {
   return `${base}.json`;
 }
 
+function mapParseDiagnostics(
+  diagnostics: readonly ParseDiagnostic[],
+  sourceFile: SourceFile,
+  sourceId: string,
+): ContractSourceDiagnostic[] {
+  return diagnostics.map((diagnostic) => ({
+    code: diagnostic.code,
+    message: diagnostic.message,
+    sourceId,
+    span: rangeToPslSpan(diagnostic.range, sourceFile),
+  }));
+}
+
 function buildColumnDescriptorMap(
   scalarTypeDescriptors: ReadonlyMap<string, string>,
   codecLookup: CodecLookup,
@@ -58,6 +74,7 @@ function buildColumnDescriptorMap(
 export function prismaContract(schemaPath: string, options: PrismaContractOptions): ContractConfig {
   return {
     source: {
+      sourceFormat: 'psl',
       inputs: [schemaPath],
       load: async (context) => {
         const [absoluteSchemaPath] = context.resolvedInputs;
@@ -84,18 +101,31 @@ export function prismaContract(schemaPath: string, options: PrismaContractOption
           });
         }
 
-        const document = parsePslDocument({
-          schema,
-          sourceId: schemaPath,
-        });
-
         const scalarTypeDescriptors = buildColumnDescriptorMap(
           context.scalarTypeDescriptors,
           context.codecLookup,
         );
 
-        const interpreted = interpretPslDocumentToSqlContract({
+        const { document, sourceFile, diagnostics: parseDiagnostics } = parse(schema);
+        const { table: symbolTable, diagnostics: symbolTableDiagnostics } = buildSymbolTable({
           document,
+          sourceFile,
+          scalarTypes: [...context.scalarTypeDescriptors.keys()],
+          pslBlockDescriptors: context.authoringContributions.pslBlockDescriptors,
+        });
+
+        // Do not short-circuit on provider-level diagnostics; recovered CST can
+        // still produce interpreter diagnostics in the same response.
+        const seedDiagnostics = [
+          ...mapParseDiagnostics(parseDiagnostics, sourceFile, schemaPath),
+          ...mapParseDiagnostics(symbolTableDiagnostics, sourceFile, schemaPath),
+        ];
+
+        const interpreted = interpretPslDocumentToSqlContract({
+          symbolTable,
+          sourceFile,
+          sourceId: schemaPath,
+          seedDiagnostics,
           target: options.target,
           authoringContributions: context.authoringContributions,
           scalarTypeDescriptors,
@@ -114,6 +144,7 @@ export function prismaContract(schemaPath: string, options: PrismaContractOption
           ),
           controlMutationDefaults: context.controlMutationDefaults,
           ...ifDefined('createNamespace', options.createNamespace),
+          codecLookup: context.codecLookup,
         });
         if (!interpreted.ok) {
           return interpreted;

package/src/psl-attribute-parsing.ts

@@ -1,9 +1,13 @@
 import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
 import type { ControlPolicy } from '@prisma-next/contract/types';
-import type { PslAttribute, PslSpan } from '@prisma-next/psl-parser';
-import { getPositionalArgument, parseQuotedStringLiteral } from '@prisma-next/psl-parser';
+import type { PslSpan, ResolvedAttribute } from '@prisma-next/psl-parser';
+import { parseQuotedStringLiteral } from '@prisma-next/psl-parser';
 
-export { getPositionalArgument, parseQuotedStringLiteral };
+export { parseQuotedStringLiteral };
+
+export function getPositionalArgument(attribute: ResolvedAttribute, index = 0): string | undefined {
+  return attribute.args.filter((arg) => arg.kind === 'positional')[index]?.value;
+}
 
 export function lowerFirst(value: string): string {
   if (value.length === 0) return value;
@@ -11,13 +15,13 @@ export function lowerFirst(value: string): string {
 }
 
 export function getAttribute(
-  attributes: readonly PslAttribute[] | undefined,
+  attributes: readonly ResolvedAttribute[] | undefined,
   name: string,
-): PslAttribute | undefined {
+): ResolvedAttribute | undefined {
   return attributes?.find((attribute) => attribute.name === name);
 }
 
-export function getNamedArgument(attribute: PslAttribute, name: string): string | undefined {
+export function getNamedArgument(attribute: ResolvedAttribute, name: string): string | undefined {
   const entry = attribute.args.find((arg) => arg.kind === 'named' && arg.name === name);
   if (!entry || entry.kind !== 'named') {
     return undefined;
@@ -26,7 +30,7 @@ export function getNamedArgument(attribute: PslAttribute, name: string): string
 }
 
 export function getPositionalArgumentEntry(
-  attribute: PslAttribute,
+  attribute: ResolvedAttribute,
   index = 0,
 ): { value: string; span: PslSpan } | undefined {
   const entries = attribute.args.filter((arg) => arg.kind === 'positional');
@@ -63,7 +67,7 @@ export function parseFieldList(value: string): readonly string[] | undefined {
 }
 
 export function parseMapName(input: {
-  readonly attribute: PslAttribute | undefined;
+  readonly attribute: ResolvedAttribute | undefined;
   readonly defaultValue: string;
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
@@ -98,7 +102,7 @@ export function parseMapName(input: {
 }
 
 export function parseConstraintMapArgument(input: {
-  readonly attribute: PslAttribute | undefined;
+  readonly attribute: ResolvedAttribute | undefined;
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly entityLabel: string;
@@ -128,7 +132,7 @@ export function parseConstraintMapArgument(input: {
   return undefined;
 }
 
-export function getPositionalArguments(attribute: PslAttribute): readonly string[] {
+export function getPositionalArguments(attribute: ResolvedAttribute): readonly string[] {
   return attribute.args
     .filter((arg) => arg.kind === 'positional')
     .map((arg) => (arg.kind === 'positional' ? arg.value : ''));
@@ -276,7 +280,7 @@ export function pushInvalidAttributeArgument(input: {
 }
 
 export function parseOptionalSingleIntegerArgument(input: {
-  readonly attribute: PslAttribute;
+  readonly attribute: ResolvedAttribute;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
   readonly entityLabel: string;
@@ -319,7 +323,7 @@ export function parseOptionalSingleIntegerArgument(input: {
 }
 
 export function parseOptionalNumericArguments(input: {
-  readonly attribute: PslAttribute;
+  readonly attribute: ResolvedAttribute;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
   readonly entityLabel: string;
@@ -374,7 +378,7 @@ export function parseOptionalNumericArguments(input: {
 }
 
 export function parseAttributeFieldList(input: {
-  readonly attribute: PslAttribute;
+  readonly attribute: ResolvedAttribute;
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly code: string;
@@ -426,7 +430,7 @@ function isControlPolicyLiteral(value: string): value is ControlPolicy {
 }
 
 export function parseControlPolicyAttribute(input: {
-  readonly attribute: PslAttribute;
+  readonly attribute: ResolvedAttribute;
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
 }): ControlPolicy | undefined {

package/src/psl-authoring-arguments.ts

@@ -1,6 +1,6 @@
 import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
 import type { AuthoringArgumentDescriptor } from '@prisma-next/framework-components/authoring';
-import type { PslAttributeArgument, PslSpan } from '@prisma-next/psl-parser';
+import type { PslSpan, ResolvedAttributeArg } from '@prisma-next/psl-parser';
 import { unquoteStringLiteral } from './psl-attribute-parsing';
 
 const INVALID_AUTHORING_ARGUMENT = Symbol('invalidAuthoringArgument');
@@ -351,7 +351,7 @@ function pushInvalidPslHelperArgument(input: {
 }
 
 export function mapPslHelperArgs(input: {
-  readonly args: readonly PslAttributeArgument[];
+  readonly args: readonly ResolvedAttributeArg[];
   readonly descriptors: readonly AuthoringArgumentDescriptor[];
   readonly helperLabel: string;
   readonly span: PslSpan;

package/src/psl-column-resolution.ts

@@ -20,12 +20,13 @@ import type {
   MutationDefaultGeneratorDescriptor,
 } from '@prisma-next/framework-components/control';
 import type {
-  PslAttribute,
-  PslField,
+  FieldSymbol,
   PslSpan,
-  PslTypeConstructorCall,
+  ResolvedAttribute,
+  ResolvedTypeConstructorCall,
 } from '@prisma-next/psl-parser';
 import { blindCast } from '@prisma-next/utils/casts';
+
 import {
   lowerDefaultFunctionWithRegistry,
   parseDefaultFunctionCall,
@@ -207,7 +208,7 @@ export function reportUnknownFieldPreset(input: {
 }
 
 export function instantiatePslTypeConstructor(input: {
-  readonly call: PslTypeConstructorCall;
+  readonly call: ResolvedTypeConstructorCall;
   readonly descriptor: AuthoringTypeConstructorDescriptor;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
@@ -265,7 +266,7 @@ function pushUnsupportedTypeConstructorDiagnostic(input: {
 }
 
 export function resolvePslTypeConstructorDescriptor(input: {
-  readonly call: PslTypeConstructorCall;
+  readonly call: ResolvedTypeConstructorCall;
   readonly authoringContributions: AuthoringContributions | undefined;
   readonly composedExtensions: ReadonlySet<string>;
   readonly familyId: string;
@@ -314,8 +315,8 @@ export function resolvePslTypeConstructorDescriptor(input: {
  *
  * Symmetric with `instantiatePslTypeConstructor` but richer: a field preset can contribute `default`, `executionDefaults`, `id`, `unique`, and `nullable` in addition to the storage-type triple. PSL → typed-args coercion happens here (via `mapPslHelperArgs`) so that `instantiateAuthoringFieldPreset` itself stays typed-input-only and TS keeps its zero-runtime-validation cost.
  */
-export function instantiatePslFieldPreset(input: {
-  readonly call: PslTypeConstructorCall;
+export function instantiateFieldPreset(input: {
+  readonly call: ResolvedTypeConstructorCall;
   readonly descriptor: AuthoringFieldPresetDescriptor;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
@@ -395,7 +396,7 @@ export type ResolveFieldTypeResult =
   | { readonly ok: false; readonly alreadyReported: boolean };
 
 export function resolveFieldTypeDescriptor(input: {
-  readonly field: PslField;
+  readonly field: FieldSymbol;
   readonly enumTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
   readonly namedTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
   readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
@@ -407,6 +408,10 @@ export function resolveFieldTypeDescriptor(input: {
   readonly sourceId: string;
   readonly entityLabel: string;
 }): ResolveFieldTypeResult {
+  // Avoid cascading unsupported-type diagnostics after invalid qualification.
+  if (input.field.malformedType) {
+    return { ok: false, alreadyReported: true };
+  }
   if (input.field.typeConstructor) {
     // Field presets carry richer semantics than type constructors, so a field preset match is the complete answer. Shared composition rejects exact cross-registry collisions before PSL resolution can observe them.
     const presetDescriptor = getAuthoringFieldPreset(
@@ -414,7 +419,7 @@ export function resolveFieldTypeDescriptor(input: {
       input.field.typeConstructor.path,
     );
     if (presetDescriptor) {
-      const instantiated = instantiatePslFieldPreset({
+      const instantiated = instantiateFieldPreset({
         call: input.field.typeConstructor,
         descriptor: presetDescriptor,
         diagnostics: input.diagnostics,
@@ -550,7 +555,7 @@ export const NATIVE_TYPE_SPECS: Readonly<Record<string, NativeTypeSpec>> = {
     codecId: 'sql/char@1',
     nativeType: 'character',
   },
-  'db.Uuid': { args: 'noArgs', baseType: 'String', codecId: null, nativeType: 'uuid' },
+  'db.Uuid': { args: 'noArgs', baseType: 'String', codecId: 'pg/uuid@1', nativeType: 'uuid' },
   'db.SmallInt': { args: 'noArgs', baseType: 'Int', codecId: 'pg/int2@1', nativeType: 'int2' },
   'db.Real': { args: 'noArgs', baseType: 'Float', codecId: 'pg/float4@1', nativeType: 'float4' },
   'db.Numeric': {
@@ -588,7 +593,7 @@ export const NATIVE_TYPE_SPECS: Readonly<Record<string, NativeTypeSpec>> = {
 };
 
 export function resolveDbNativeTypeAttribute(input: {
-  readonly attribute: PslAttribute;
+  readonly attribute: ResolvedAttribute;
   readonly baseType: string;
   readonly baseDescriptor: ColumnDescriptor;
   readonly diagnostics: ContractSourceDiagnostic[];
@@ -703,7 +708,7 @@ export function parseDefaultLiteralValue(expression: string): ColumnDefault | un
 export function lowerDefaultForField(input: {
   readonly modelName: string;
   readonly fieldName: string;
-  readonly defaultAttribute: PslAttribute;
+  readonly defaultAttribute: ResolvedAttribute;
   readonly columnDescriptor: ColumnDescriptor;
   readonly generatorDescriptorById: ReadonlyMap<string, MutationDefaultGeneratorDescriptor>;
   readonly sourceId: string;
@@ -809,14 +814,11 @@ export function lowerDefaultForField(input: {
 }
 
 export function resolveColumnDescriptor(
-  field: PslField,
+  field: FieldSymbol,
   enumTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>,
   namedTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>,
   scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>,
 ): ColumnDescriptor | undefined {
-  if (field.typeRef && namedTypeDescriptors.has(field.typeRef)) {
-    return namedTypeDescriptors.get(field.typeRef);
-  }
   if (namedTypeDescriptors.has(field.typeName)) {
     return namedTypeDescriptors.get(field.typeName);
   }

package/src/psl-field-resolution.ts

@@ -1,11 +1,17 @@
 import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
-import type { ColumnDefault, ExecutionMutationDefaultPhases } from '@prisma-next/contract/types';
+import type {
+  ColumnDefault,
+  ColumnDefaultLiteralInputValue,
+  ExecutionMutationDefaultPhases,
+} from '@prisma-next/contract/types';
 import type { AuthoringContributions } from '@prisma-next/framework-components/authoring';
 import type {
   ControlMutationDefaultRegistry,
   MutationDefaultGeneratorDescriptor,
 } from '@prisma-next/framework-components/control';
-import type { PslAttribute, PslField, PslModel } from '@prisma-next/psl-parser';
+import type { FieldSymbol, ModelSymbol, ResolvedAttribute } from '@prisma-next/psl-parser';
+import type { EnumTypeHandle } from '@prisma-next/sql-contract-ts/contract-builder';
+import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import {
   getAttribute,
@@ -21,10 +27,74 @@ import {
   resolveFieldTypeDescriptor,
 } from './psl-column-resolution';
 
+type LoweredFieldDefault = {
+  readonly defaultValue?: ColumnDefault;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
+};
+
+function lowerEnumDefaultForField(input: {
+  readonly modelName: string;
+  readonly fieldName: string;
+  readonly defaultAttribute: ResolvedAttribute;
+  readonly enumHandle: EnumTypeHandle;
+  readonly sourceId: string;
+  readonly diagnostics: ContractSourceDiagnostic[];
+}): LoweredFieldDefault {
+  const positionalEntries = input.defaultAttribute.args.filter((arg) => arg.kind === 'positional');
+  const hasNamedEntries = input.defaultAttribute.args.some((arg) => arg.kind === 'named');
+  const expressionEntry = positionalEntries[0];
+  if (hasNamedEntries || positionalEntries.length !== 1 || expressionEntry === undefined) {
+    input.diagnostics.push({
+      code: 'PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT',
+      message: `Field "${input.modelName}.${input.fieldName}" @default on an enum field expects exactly one positional enum member argument.`,
+      sourceId: input.sourceId,
+      span: input.defaultAttribute.span,
+    });
+    return {};
+  }
+
+  const raw = expressionEntry.value.trim();
+  const isQuotedString = /^(['"]).*\1$/.test(raw);
+  const isFunctionCall = raw.includes('(') && raw.endsWith(')');
+
+  if (isQuotedString || isFunctionCall) {
+    input.diagnostics.push({
+      code: 'PSL_ENUM_DEFAULT_MUST_BE_MEMBER_NAME',
+      message: `Field "${input.modelName}.${input.fieldName}" @default on an enum field must name a member (e.g. @default(Low)), not a raw value or function.`,
+      sourceId: input.sourceId,
+      span: input.defaultAttribute.span,
+    });
+    return {};
+  }
+
+  const match = input.enumHandle.enumMembers.find((m) => m.name === raw);
+  if (!match) {
+    const validNames = input.enumHandle.enumMembers.map((m) => m.name).join(', ');
+    input.diagnostics.push({
+      code: 'PSL_ENUM_UNKNOWN_DEFAULT_MEMBER',
+      message: `Field "${input.modelName}.${input.fieldName}" @default(${raw}) does not name a member of ${input.enumHandle.enumName}. Valid members: ${validNames}.`,
+      sourceId: input.sourceId,
+      span: input.defaultAttribute.span,
+    });
+    return {};
+  }
+
+  return {
+    defaultValue: {
+      kind: 'literal',
+      value: blindCast<
+        ColumnDefaultLiteralInputValue,
+        'enum member values are codec-validated JsonValue-compatible scalars'
+      >(match.value),
+    },
+  };
+}
+
 export type ResolvedField = {
-  readonly field: PslField;
+  readonly field: FieldSymbol;
   readonly columnName: string;
   readonly descriptor: ColumnDescriptor;
+  readonly nullable: boolean;
   readonly defaultValue?: ColumnDefault;
   readonly executionDefaults?: ExecutionMutationDefaultPhases;
   readonly isId: boolean;
@@ -37,7 +107,7 @@ export type ResolvedField = {
 };
 
 export type ModelNameMapping = {
-  readonly model: PslModel;
+  readonly model: ModelSymbol;
   readonly tableName: string;
   readonly fieldColumns: Map<string, string>;
 };
@@ -50,7 +120,7 @@ export type ModelNameMapping = {
  * {@link modelCoordinateKey} rather than the bare model name.
  */
 export type ModelNamespaceEntry = {
-  readonly model: PslModel;
+  readonly model: ModelSymbol;
   readonly namespaceId: string | undefined;
 };
 
@@ -61,7 +131,7 @@ export function modelCoordinateKey(namespaceId: string, modelName: string): stri
 }
 
 export interface CollectResolvedFieldsInput {
-  readonly model: PslModel;
+  readonly model: ModelSymbol;
   readonly mapping: ModelNameMapping;
   readonly enumTypeDescriptors: Map<string, ColumnDescriptor>;
   readonly namedTypeDescriptors: Map<string, ColumnDescriptor>;
@@ -76,6 +146,7 @@ export interface CollectResolvedFieldsInput {
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
   readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly enumHandles?: ReadonlyMap<string, EnumTypeHandle>;
 }
 
 const BUILTIN_FIELD_ATTRIBUTE_NAMES: ReadonlySet<string> = new Set([
@@ -95,12 +166,12 @@ const BUILTIN_FIELD_ATTRIBUTE_NAMES: ReadonlySet<string> = new Set([
  * migrated (so they don't get told to do what they just did).
  *
  * Pairing the suppression predicate with the hint makes each entry
- * self-contained: a future entry for, say, `@id` ↔ `id.uuidv7()` cannot
+ * self-contained: a future entry for, say, `@id` ↔ `id.uuidv7String()` cannot
  * silently inherit the wrong predicate when added.
  */
 interface RemovedAttributeRule {
   readonly hint: string;
-  readonly suppressWhen: (field: PslField) => boolean;
+  readonly suppressWhen: (field: FieldSymbol) => boolean;
 }
 
 const REMOVED_ATTRIBUTE_RULES: ReadonlyMap<string, RemovedAttributeRule> = new Map([
@@ -130,8 +201,8 @@ const REMOVED_ATTRIBUTE_RULES: ReadonlyMap<string, RemovedAttributeRule> = new M
 }
 
 function validateFieldAttributes(input: {
-  readonly model: PslModel;
-  readonly field: PslField;
+  readonly model: ModelSymbol;
+  readonly field: FieldSymbol;
   readonly composedExtensions: ReadonlySet<string>;
   readonly authoringContributions: AuthoringContributions | undefined;
   readonly diagnostics: ContractSourceDiagnostic[];
@@ -177,13 +248,13 @@ function validateFieldAttributes(input: {
 }
 
 function extractFieldConstraintNames(input: {
-  readonly model: PslModel;
-  readonly field: PslField;
+  readonly model: ModelSymbol;
+  readonly field: FieldSymbol;
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
 }): {
-  readonly idAttribute: PslAttribute | undefined;
-  readonly uniqueAttribute: PslAttribute | undefined;
+  readonly idAttribute: ResolvedAttribute | undefined;
+  readonly uniqueAttribute: ResolvedAttribute | undefined;
   readonly idName: string | undefined;
   readonly uniqueName: string | undefined;
 } {
@@ -225,10 +296,11 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
     diagnostics,
     sourceId,
     scalarTypeDescriptors,
+    enumHandles,
   } = input;
   const resolvedFields: ResolvedField[] = [];
 
-  for (const field of model.fields) {
+  for (const field of Object.values(model.fields)) {
     const isModelField = modelNames.has(field.typeName);
 
     if (field.list && isModelField) {
@@ -350,17 +422,27 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
       });
       continue;
     }
-    const loweredDefault = defaultAttribute
-      ? lowerDefaultForField({
-          modelName: model.name,
-          fieldName: field.name,
-          defaultAttribute,
-          columnDescriptor: descriptor,
-          generatorDescriptorById,
-          sourceId,
-          defaultFunctionRegistry,
-          diagnostics,
-        })
+    const enumHandle = enumHandles?.get(field.typeName);
+    const loweredDefault: LoweredFieldDefault = defaultAttribute
+      ? enumHandle
+        ? lowerEnumDefaultForField({
+            modelName: model.name,
+            fieldName: field.name,
+            defaultAttribute,
+            enumHandle,
+            sourceId,
+            diagnostics,
+          })
+        : lowerDefaultForField({
+            modelName: model.name,
+            fieldName: field.name,
+            defaultAttribute,
+            columnDescriptor: descriptor,
+            generatorDescriptorById,
+            sourceId,
+            defaultFunctionRegistry,
+            diagnostics,
+          })
       : {};
     const loweredOnCreate = loweredDefault.executionDefaults?.onCreate;
     if (field.optional && loweredOnCreate) {
@@ -374,7 +456,8 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
       });
       continue;
     }
-    if (loweredOnCreate) {
+    const fieldUsesNamedType = namedTypeDescriptors.has(field.typeName);
+    if (loweredOnCreate && !fieldUsesNamedType) {
       const generatorDescriptor = generatorDescriptorById.get(loweredOnCreate.id);
       const generatedDescriptor = generatorDescriptor?.resolveGeneratedColumnDescriptor?.({
         generated: loweredOnCreate,
@@ -426,6 +509,7 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
       field,
       columnName: mappedColumnName,
       descriptor,
+      nullable: presetContributions?.nullable ?? field.optional,
       ...ifDefined('defaultValue', fieldDefaultValue),
       ...ifDefined('executionDefaults', fieldExecutionDefaults),
       isId: isIdField || Boolean(presetContributions?.id),
@@ -459,7 +543,7 @@ export function buildModelMappings(
       span: model.span,
     });
     const fieldColumns = new Map<string, string>();
-    for (const field of model.fields) {
+    for (const field of Object.values(model.fields)) {
       const fieldMapAttribute = getAttribute(field.attributes, 'map');
       const columnName = parseMapName({
         attribute: fieldMapAttribute,