@prisma-next/family-sql 0.3.0-dev.34 → 0.3.0-dev.36

package/src/core/assembly.ts

@@ -1,37 +1,58 @@
 import type {
   NormalizedTypeRenderer,
+  TargetBoundComponentDescriptor,
   TypeRenderer,
 } from '@prisma-next/contract/framework-components';
 import { normalizeRenderer } from '@prisma-next/contract/framework-components';
-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';
+import type { OperationRegistry } from '@prisma-next/operations';
 import { createOperationRegistry } from '@prisma-next/operations';
+import type { CodecControlHooks, 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 };
+  };
+}
 
-/**
- * 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);
     }
   }
@@ -39,15 +60,20 @@ 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 };
+  };
+}
+
 export function extractCodecTypeImports(
-  descriptors: ReadonlyArray<
-    | ControlTargetDescriptor<'sql', string>
-    | ControlAdapterDescriptor<'sql', string>
-    | ControlExtensionDescriptor<'sql', string>
-  >,
+  descriptors: ReadonlyArray<DescriptorWithTypes>,
 ): ReadonlyArray<TypesImportSpec> {
   const imports: TypesImportSpec[] = [];
 
@@ -65,15 +91,8 @@ export function extractCodecTypeImports(
   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[] = [];
 
@@ -88,60 +107,29 @@ 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 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);
 
-  // Add target second
-  if (!seen.has(target.id)) {
-    ids.push(target.id);
-    seen.add(target.id);
-  }
-
-  // Add extensions in order
   for (const ext of extensions) {
-    if (!seen.has(ext.id)) {
-      ids.push(ext.id);
-      seen.add(ext.id);
-    }
+    addUniqueId(ids, seen, ext.id);
   }
 
   return ids;
 }
 
-/**
- * Extracts and normalizes parameterized codec renderers from descriptors.
- * Templates are compiled to functions at this layer.
- *
- * Throws an error if multiple descriptors provide a renderer for the same codecId.
- * This is intentional - duplicate codecId is a hard error, not a silent override.
- *
- * @returns Map from codecId to normalized renderer
- */
 export function extractParameterizedRenderers(
-  descriptors: ReadonlyArray<
-    | ControlTargetDescriptor<'sql', string>
-    | ControlAdapterDescriptor<'sql', string>
-    | ControlExtensionDescriptor<'sql', string>
-  >,
+  descriptors: ReadonlyArray<DescriptorWithTypes>,
 ): Map<string, NormalizedTypeRenderer> {
   const renderers = new Map<string, NormalizedTypeRenderer>();
-  const owners = new Map<string, string>(); // codecId -> descriptor.id for error messages
+  const owners = new Map<string, string>();
 
   for (const descriptor of descriptors) {
     const codecTypes = descriptor.types?.codecTypes;
@@ -149,15 +137,13 @@ export function extractParameterizedRenderers(
 
     const parameterized: Record<string, TypeRenderer> = codecTypes.parameterized;
     for (const [codecId, renderer] of Object.entries(parameterized)) {
-      const existingOwner = owners.get(codecId);
-      if (existingOwner !== undefined) {
-        throw new Error(
-          `Duplicate parameterized renderer for codecId "${codecId}". ` +
-            `Descriptor "${descriptor.id}" conflicts with "${existingOwner}". ` +
-            'Each codecId can only have one renderer.',
-        );
-      }
-
+      assertUniqueCodecOwner({
+        codecId,
+        owners,
+        descriptorId: descriptor.id,
+        entityLabel: 'parameterized renderer',
+        entityOwnershipLabel: 'renderer',
+      });
       renderers.set(codecId, normalizeRenderer(codecId, renderer));
       owners.set(codecId, descriptor.id);
     }
@@ -166,18 +152,56 @@ export function extractParameterizedRenderers(
   return renderers;
 }
 
-/**
- * Extracts parameterized type imports from descriptors for contract.d.ts generation.
- * These are type imports needed by parameterized codec renderers.
- *
- * @returns Array of type import specs (may contain duplicates; caller should deduplicate)
- */
+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 hooks;
+}
+
 export function extractParameterizedTypeImports(
-  descriptors: ReadonlyArray<
-    | ControlTargetDescriptor<'sql', string>
-    | ControlAdapterDescriptor<'sql', string>
-    | ControlExtensionDescriptor<'sql', string>
-  >,
+  descriptors: ReadonlyArray<DescriptorWithTypes>,
 ): ReadonlyArray<TypesImportSpec> {
   const imports: TypesImportSpec[] = [];
 

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,
     });
   }
 }