@prisma-next/family-sql 0.3.0-dev.7 → 0.3.0-dev.71

package/src/core/assembly.ts

@@ -1,32 +1,58 @@
-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, 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);
     }
   }
@@ -34,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[] = [];
 
@@ -52,20 +83,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 +107,110 @@ 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);
+
+  for (const ext of extensions) {
+    addUniqueId(ids, seen, ext.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 target second
-  if (!seen.has(target.id)) {
-    ids.push(target.id);
-    seen.add(target.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';
+}
 
-  // Add extensions in order
-  for (const ext of extensions) {
-    if (!seen.has(ext.id)) {
-      ids.push(ext.id);
-      seen.add(ext.id);
+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;
 }

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/control-descriptor.ts

@@ -0,0 +1,37 @@
+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 type { SqlControlDescriptorWithContributions } from './assembly';
+import { createSqlFamilyInstance, type SqlControlFamilyInstance } from './control-instance';
+import type {
+  SqlControlAdapterDescriptor,
+  SqlControlExtensionDescriptor,
+} from './migrations/types';
+
+export class SqlFamilyDescriptor
+  implements ControlFamilyDescriptor<'sql', SqlControlFamilyInstance>
+{
+  readonly kind = 'family' as const;
+  readonly id = 'sql';
+  readonly familyId = 'sql' as const;
+  readonly version = '0.0.1';
+  readonly hook = sqlTargetFamilyHook;
+
+  create<TTargetId extends string>(
+    stack: ControlPlaneStack<'sql', TTargetId>,
+  ): SqlControlFamilyInstance {
+    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,
+      adapter,
+      extensionPacks,
+    });
+  }
+}