@prisma-next/family-sql 0.3.0-dev.12 → 0.3.0-dev.122

package/src/core/assembly.ts

@@ -1,32 +1,74 @@
-import type { OperationManifest } from '@prisma-next/contract/pack-manifest-types';
-import type { TypesImportSpec } from '@prisma-next/contract/types';
 import type {
-  ControlAdapterDescriptor,
-  ControlExtensionDescriptor,
-  ControlTargetDescriptor,
-} from '@prisma-next/core-control-plane/types';
-import type { OperationRegistry, OperationSignature } from '@prisma-next/operations';
+  NormalizedTypeRenderer,
+  TargetBoundComponentDescriptor,
+  TypeRenderer,
+} from '@prisma-next/contract/framework-components';
+import { normalizeRenderer } from '@prisma-next/contract/framework-components';
+import type { TypesImportSpec } from '@prisma-next/contract/types';
+import type { OperationRegistry } from '@prisma-next/operations';
 import { createOperationRegistry } from '@prisma-next/operations';
+import type {
+  CodecControlHooks,
+  ControlMutationDefaultFunctionEntry,
+  ControlMutationDefaultGeneratorDescriptor,
+  PslScalarTypeDescriptor,
+  SqlControlStaticContributions,
+} from './migrations/types';
+
+function addUniqueId(ids: string[], seen: Set<string>, id: string): void {
+  if (!seen.has(id)) {
+    ids.push(id);
+    seen.add(id);
+  }
+}
+
+function assertUniqueCodecOwner(options: {
+  readonly codecId: string;
+  readonly owners: Map<string, string>;
+  readonly descriptorId: string;
+  readonly entityLabel: string;
+  readonly entityOwnershipLabel: string;
+}): void {
+  const existingOwner = options.owners.get(options.codecId);
+  if (existingOwner !== undefined) {
+    throw new Error(
+      `Duplicate ${options.entityLabel} for codecId "${options.codecId}". ` +
+        `Descriptor "${options.descriptorId}" conflicts with "${existingOwner}". ` +
+        `Each codecId can only have one ${options.entityOwnershipLabel}.`,
+    );
+  }
+}
+
+export interface SqlControlDescriptorWithContributions extends SqlControlStaticContributions {
+  readonly id: string;
+  readonly types?: {
+    readonly codecTypes?: {
+      readonly import?: TypesImportSpec;
+      readonly parameterized?: Record<string, TypeRenderer>;
+      readonly typeImports?: ReadonlyArray<TypesImportSpec>;
+    };
+    readonly operationTypes?: { readonly import: TypesImportSpec };
+  };
+}
+
+export interface AssembledControlMutationDefaultContributions {
+  readonly defaultFunctionRegistry: ReadonlyMap<string, ControlMutationDefaultFunctionEntry>;
+  readonly generatorDescriptors: readonly ControlMutationDefaultGeneratorDescriptor[];
+}
+
+export interface AssembledPslInterpretationContributions
+  extends AssembledControlMutationDefaultContributions {
+  readonly scalarTypeDescriptors: ReadonlyMap<string, PslScalarTypeDescriptor>;
+}
 
-/**
- * Assembles an operation registry from descriptors (adapter, target, extensions).
- * Loops over descriptors, extracts operations, converts them using the provided
- * conversion function, and registers them in a new registry.
- */
 export function assembleOperationRegistry(
-  descriptors: ReadonlyArray<
-    | ControlTargetDescriptor<'sql', string>
-    | ControlAdapterDescriptor<'sql', string>
-    | ControlExtensionDescriptor<'sql', string>
-  >,
-  convertOperationManifest: (manifest: OperationManifest) => OperationSignature,
+  descriptors: ReadonlyArray<SqlControlDescriptorWithContributions>,
 ): OperationRegistry {
   const registry = createOperationRegistry();
 
   for (const descriptor of descriptors) {
-    const operations = descriptor.operations ?? [];
-    for (const operationManifest of operations as ReadonlyArray<OperationManifest>) {
-      const signature = convertOperationManifest(operationManifest);
+    const signatures = descriptor.operationSignatures();
+    for (const signature of signatures) {
       registry.register(signature);
     }
   }
@@ -34,15 +76,21 @@ export function assembleOperationRegistry(
   return registry;
 }
 
-/**
- * Extracts codec type imports from descriptors for contract.d.ts generation.
- */
+interface DescriptorWithTypes {
+  readonly id: string;
+  readonly types?: {
+    readonly codecTypes?: {
+      readonly import?: TypesImportSpec;
+      readonly parameterized?: Record<string, TypeRenderer>;
+      readonly typeImports?: ReadonlyArray<TypesImportSpec>;
+    };
+    readonly operationTypes?: { readonly import: TypesImportSpec };
+    readonly queryOperationTypes?: { readonly import: TypesImportSpec };
+  };
+}
+
 export function extractCodecTypeImports(
-  descriptors: ReadonlyArray<
-    | ControlTargetDescriptor<'sql', string>
-    | ControlAdapterDescriptor<'sql', string>
-    | ControlExtensionDescriptor<'sql', string>
-  >,
+  descriptors: ReadonlyArray<DescriptorWithTypes>,
 ): ReadonlyArray<TypesImportSpec> {
   const imports: TypesImportSpec[] = [];
 
@@ -52,20 +100,16 @@ export function extractCodecTypeImports(
     if (codecTypes?.import) {
       imports.push(codecTypes.import);
     }
+    if (codecTypes?.typeImports) {
+      imports.push(...codecTypes.typeImports);
+    }
   }
 
   return imports;
 }
 
-/**
- * Extracts operation type imports from descriptors for contract.d.ts generation.
- */
 export function extractOperationTypeImports(
-  descriptors: ReadonlyArray<
-    | ControlTargetDescriptor<'sql', string>
-    | ControlAdapterDescriptor<'sql', string>
-    | ControlExtensionDescriptor<'sql', string>
-  >,
+  descriptors: ReadonlyArray<DescriptorWithTypes>,
 ): ReadonlyArray<TypesImportSpec> {
   const imports: TypesImportSpec[] = [];
 
@@ -80,38 +124,200 @@ export function extractOperationTypeImports(
   return imports;
 }
 
-/**
- * Extracts extension IDs from descriptors in deterministic order:
- * [adapter.id, target.id, ...extensions.map(e => e.id)]
- * Deduplicates while preserving stable order.
- */
+export function extractQueryOperationTypeImports(
+  descriptors: ReadonlyArray<DescriptorWithTypes>,
+): ReadonlyArray<TypesImportSpec> {
+  const imports: TypesImportSpec[] = [];
+
+  for (const descriptor of descriptors) {
+    const types = descriptor.types;
+    const queryOperationTypes = types?.queryOperationTypes;
+    if (queryOperationTypes?.import) {
+      imports.push(queryOperationTypes.import);
+    }
+  }
+
+  return imports;
+}
+
 export function extractExtensionIds(
-  adapter: ControlAdapterDescriptor<'sql', string>,
-  target: ControlTargetDescriptor<'sql', string>,
-  extensions: ReadonlyArray<ControlExtensionDescriptor<'sql', string>>,
+  adapter: { readonly id: string },
+  target: { readonly id: string },
+  extensions: ReadonlyArray<{ readonly id: string }>,
 ): ReadonlyArray<string> {
   const ids: string[] = [];
   const seen = new Set<string>();
 
-  // Add adapter first
-  if (!seen.has(adapter.id)) {
-    ids.push(adapter.id);
-    seen.add(adapter.id);
+  addUniqueId(ids, seen, adapter.id);
+  addUniqueId(ids, seen, target.id);
+
+  for (const ext of extensions) {
+    addUniqueId(ids, seen, ext.id);
   }
 
-  // Add target second
-  if (!seen.has(target.id)) {
-    ids.push(target.id);
-    seen.add(target.id);
+  return ids;
+}
+
+export function extractParameterizedRenderers(
+  descriptors: ReadonlyArray<DescriptorWithTypes>,
+): Map<string, NormalizedTypeRenderer> {
+  const renderers = new Map<string, NormalizedTypeRenderer>();
+  const owners = new Map<string, string>();
+
+  for (const descriptor of descriptors) {
+    const codecTypes = descriptor.types?.codecTypes;
+    if (!codecTypes?.parameterized) continue;
+
+    const parameterized: Record<string, TypeRenderer> = codecTypes.parameterized;
+    for (const [codecId, renderer] of Object.entries(parameterized)) {
+      assertUniqueCodecOwner({
+        codecId,
+        owners,
+        descriptorId: descriptor.id,
+        entityLabel: 'parameterized renderer',
+        entityOwnershipLabel: 'renderer',
+      });
+      renderers.set(codecId, normalizeRenderer(codecId, renderer));
+      owners.set(codecId, descriptor.id);
+    }
   }
 
-  // Add extensions in order
-  for (const ext of extensions) {
-    if (!seen.has(ext.id)) {
-      ids.push(ext.id);
-      seen.add(ext.id);
+  return renderers;
+}
+
+type CodecControlHooksMap = Record<string, CodecControlHooks>;
+
+function hasCodecControlHooks(descriptor: unknown): descriptor is {
+  readonly id: string;
+  readonly types: {
+    readonly codecTypes: {
+      readonly controlPlaneHooks: CodecControlHooksMap;
+    };
+  };
+} {
+  if (typeof descriptor !== 'object' || descriptor === null) {
+    return false;
+  }
+  const d = descriptor as { types?: { codecTypes?: { controlPlaneHooks?: unknown } } };
+  const hooks = d.types?.codecTypes?.controlPlaneHooks;
+  return hooks !== null && hooks !== undefined && typeof hooks === 'object';
+}
+
+export function extractCodecControlHooks(
+  descriptors: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>,
+): Map<string, CodecControlHooks> {
+  const hooks = new Map<string, CodecControlHooks>();
+  const owners = new Map<string, string>();
+
+  for (const descriptor of descriptors) {
+    if (typeof descriptor !== 'object' || descriptor === null) {
+      continue;
+    }
+    if (!hasCodecControlHooks(descriptor)) {
+      continue;
+    }
+    const controlPlaneHooks = descriptor.types.codecTypes.controlPlaneHooks;
+    for (const [codecId, hook] of Object.entries(controlPlaneHooks)) {
+      assertUniqueCodecOwner({
+        codecId,
+        owners,
+        descriptorId: descriptor.id,
+        entityLabel: 'control hooks',
+        entityOwnershipLabel: 'owner',
+      });
+      hooks.set(codecId, hook);
+      owners.set(codecId, descriptor.id);
     }
   }
 
-  return ids;
+  return hooks;
+}
+
+export function extractParameterizedTypeImports(
+  descriptors: ReadonlyArray<DescriptorWithTypes>,
+): ReadonlyArray<TypesImportSpec> {
+  const imports: TypesImportSpec[] = [];
+
+  for (const descriptor of descriptors) {
+    const typeImports = descriptor.types?.codecTypes?.typeImports;
+    if (typeImports) {
+      imports.push(...typeImports);
+    }
+  }
+
+  return imports;
+}
+
+export function assembleControlMutationDefaultContributions(
+  descriptors: ReadonlyArray<SqlControlDescriptorWithContributions>,
+): AssembledControlMutationDefaultContributions {
+  const defaultFunctionRegistry = new Map<string, ControlMutationDefaultFunctionEntry>();
+  const functionOwners = new Map<string, string>();
+  const generatorMap = new Map<string, ControlMutationDefaultGeneratorDescriptor>();
+  const generatorOwners = new Map<string, string>();
+
+  for (const descriptor of descriptors) {
+    const contributions = descriptor.controlMutationDefaults?.();
+    if (!contributions) {
+      continue;
+    }
+
+    for (const generatorDescriptor of contributions.generatorDescriptors) {
+      const owner = generatorOwners.get(generatorDescriptor.id);
+      if (owner) {
+        throw new Error(
+          `Duplicate mutation default generator id "${generatorDescriptor.id}". Descriptor "${descriptor.id}" conflicts with "${owner}".`,
+        );
+      }
+      generatorMap.set(generatorDescriptor.id, generatorDescriptor);
+      generatorOwners.set(generatorDescriptor.id, descriptor.id);
+    }
+
+    for (const [functionName, handler] of contributions.defaultFunctionRegistry) {
+      const owner = functionOwners.get(functionName);
+      if (owner) {
+        throw new Error(
+          `Duplicate mutation default function "${functionName}". Descriptor "${descriptor.id}" conflicts with "${owner}".`,
+        );
+      }
+      defaultFunctionRegistry.set(functionName, handler);
+      functionOwners.set(functionName, descriptor.id);
+    }
+  }
+
+  return {
+    defaultFunctionRegistry,
+    generatorDescriptors: Array.from(generatorMap.values()),
+  };
+}
+
+export function assemblePslInterpretationContributions(
+  descriptors: ReadonlyArray<SqlControlDescriptorWithContributions>,
+): AssembledPslInterpretationContributions {
+  const mutationDefaults = assembleControlMutationDefaultContributions(descriptors);
+  const scalarTypeDescriptors = new Map<string, PslScalarTypeDescriptor>();
+  const scalarOwners = new Map<string, string>();
+
+  for (const descriptor of descriptors) {
+    const pslTypeContributions = descriptor.pslTypeDescriptors?.();
+    if (!pslTypeContributions) {
+      continue;
+    }
+
+    for (const [typeName, scalarDescriptor] of pslTypeContributions.scalarTypeDescriptors) {
+      const owner = scalarOwners.get(typeName);
+      if (owner) {
+        throw new Error(
+          `Duplicate PSL scalar type descriptor "${typeName}". Descriptor "${descriptor.id}" conflicts with "${owner}".`,
+        );
+      }
+      scalarTypeDescriptors.set(typeName, scalarDescriptor);
+      scalarOwners.set(typeName, descriptor.id);
+    }
+  }
+
+  return {
+    ...mutationDefaults,
+    scalarTypeDescriptors,
+  };
 }

package/src/core/control-adapter.ts

@@ -3,6 +3,7 @@ import type {
   ControlDriverInstance,
 } from '@prisma-next/core-control-plane/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+import type { DefaultNormalizer, NativeTypeNormalizer } from './schema-verify/verify-sql-schema';
 
 /**
  * SQL control adapter interface for control-plane operations.
@@ -36,6 +37,20 @@ export interface SqlControlAdapter<TTarget extends string = string>
     contractIR?: unknown,
     schema?: string,
   ): Promise<SqlSchemaIR>;
+
+  /**
+   * Optional target-specific normalizer for raw database default expressions.
+   * When provided, schema defaults (raw strings) are normalized before comparison
+   * with contract defaults (ColumnDefault objects) during schema verification.
+   */
+  readonly normalizeDefault?: DefaultNormalizer;
+
+  /**
+   * Optional target-specific normalizer for schema native type names.
+   * When provided, schema native types (from introspection) are normalized
+   * before comparison with contract native types during schema verification.
+   */
+  readonly normalizeNativeType?: NativeTypeNormalizer;
 }
 
 /**

package/src/core/{descriptor.ts → control-descriptor.ts}

@@ -1,14 +1,16 @@
+import type { TargetDescriptor } from '@prisma-next/contract/framework-components';
 import type {
   ControlFamilyDescriptor,
   ControlPlaneStack,
 } from '@prisma-next/core-control-plane/types';
 import { sqlTargetFamilyHook } from '@prisma-next/sql-contract-emitter';
-import { createSqlFamilyInstance, type SqlControlFamilyInstance } from './instance';
+import type { SqlControlDescriptorWithContributions } from './assembly';
+import { createSqlFamilyInstance, type SqlControlFamilyInstance } from './control-instance';
+import type {
+  SqlControlAdapterDescriptor,
+  SqlControlExtensionDescriptor,
+} from './migrations/types';
 
-/**
- * SQL family descriptor implementation.
- * Provides the SQL family hook and factory method.
- */
 export class SqlFamilyDescriptor
   implements ControlFamilyDescriptor<'sql', SqlControlFamilyInstance>
 {
@@ -21,13 +23,15 @@ export class SqlFamilyDescriptor
   create<TTargetId extends string>(
     stack: ControlPlaneStack<'sql', TTargetId>,
   ): SqlControlFamilyInstance {
-    // Note: driver is not passed here because SqlFamilyInstance operations
-    // (validate, emit, etc.) don't require DB connectivity. Commands that
-    // need the driver (verify, introspect) get it directly from the stack.
+    const target = stack.target as unknown as TargetDescriptor<'sql', TTargetId> &
+      SqlControlDescriptorWithContributions;
+    const adapter = stack.adapter as unknown as SqlControlAdapterDescriptor<TTargetId>;
+    const extensionPacks =
+      stack.extensionPacks as unknown as readonly SqlControlExtensionDescriptor<TTargetId>[];
     return createSqlFamilyInstance({
-      target: stack.target,
-      adapter: stack.adapter,
-      extensionPacks: stack.extensionPacks,
+      target,
+      adapter,
+      extensionPacks,
     });
   }
 }