@prisma-next/family-sql 0.3.0-dev.3 → 0.3.0-dev.30

package/src/core/assembly.ts

@@ -0,0 +1,189 @@
+import type {
+  NormalizedTypeRenderer,
+  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 { createOperationRegistry } from '@prisma-next/operations';
+
+/**
+ * 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,
+): 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);
+      registry.register(signature);
+    }
+  }
+
+  return registry;
+}
+
+/**
+ * Extracts codec type imports from descriptors for contract.d.ts generation.
+ */
+export function extractCodecTypeImports(
+  descriptors: ReadonlyArray<
+    | ControlTargetDescriptor<'sql', string>
+    | ControlAdapterDescriptor<'sql', string>
+    | ControlExtensionDescriptor<'sql', string>
+  >,
+): ReadonlyArray<TypesImportSpec> {
+  const imports: TypesImportSpec[] = [];
+
+  for (const descriptor of descriptors) {
+    const types = descriptor.types;
+    const codecTypes = types?.codecTypes;
+    if (codecTypes?.import) {
+      imports.push(codecTypes.import);
+    }
+  }
+
+  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>
+  >,
+): ReadonlyArray<TypesImportSpec> {
+  const imports: TypesImportSpec[] = [];
+
+  for (const descriptor of descriptors) {
+    const types = descriptor.types;
+    const operationTypes = types?.operationTypes;
+    if (operationTypes?.import) {
+      imports.push(operationTypes.import);
+    }
+  }
+
+  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>>,
+): 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);
+  }
+
+  // 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);
+    }
+  }
+
+  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>
+  >,
+): Map<string, NormalizedTypeRenderer> {
+  const renderers = new Map<string, NormalizedTypeRenderer>();
+  const owners = new Map<string, string>(); // codecId -> descriptor.id for error messages
+
+  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)) {
+      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.',
+        );
+      }
+
+      renderers.set(codecId, normalizeRenderer(codecId, renderer));
+      owners.set(codecId, descriptor.id);
+    }
+  }
+
+  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)
+ */
+export function extractParameterizedTypeImports(
+  descriptors: ReadonlyArray<
+    | ControlTargetDescriptor<'sql', string>
+    | ControlAdapterDescriptor<'sql', string>
+    | ControlExtensionDescriptor<'sql', string>
+  >,
+): ReadonlyArray<TypesImportSpec> {
+  const imports: TypesImportSpec[] = [];
+
+  for (const descriptor of descriptors) {
+    const parameterizedImports = descriptor.types?.codecTypes?.parameterizedImports;
+    if (parameterizedImports) {
+      imports.push(...parameterizedImports);
+    }
+  }
+
+  return imports;
+}

package/src/core/control-adapter.ts

@@ -0,0 +1,52 @@
+import type {
+  ControlAdapterInstance,
+  ControlDriverInstance,
+} from '@prisma-next/core-control-plane/types';
+import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+
+/**
+ * SQL control adapter interface for control-plane operations.
+ * Implemented by target-specific adapters (e.g., Postgres, MySQL).
+ *
+ * @template TTarget - The target ID (e.g., 'postgres', 'mysql')
+ */
+export interface SqlControlAdapter<TTarget extends string = string>
+  extends ControlAdapterInstance<'sql', TTarget> {
+  /**
+   * The target ID this adapter implements.
+   * Used for type tracking and runtime validation.
+   * @deprecated Use targetId from ControlAdapterInstance instead
+   */
+  readonly target: TTarget;
+
+  /**
+   * Introspects a database schema and returns a raw SqlSchemaIR.
+   *
+   * This is a pure schema discovery operation that queries the database catalog
+   * and returns the schema structure without type mapping or contract enrichment.
+   * Type mapping and enrichment are handled separately by enrichment helpers.
+   *
+   * @param driver - ControlDriverInstance instance for executing queries (target-specific)
+   * @param contractIR - Optional contract IR for contract-guided introspection (filtering, optimization)
+   * @param schema - Schema name to introspect (defaults to 'public')
+   * @returns Promise resolving to SqlSchemaIR representing the live database schema
+   */
+  introspect(
+    driver: ControlDriverInstance<'sql', TTarget>,
+    contractIR?: unknown,
+    schema?: string,
+  ): Promise<SqlSchemaIR>;
+}
+
+/**
+ * SQL control adapter descriptor interface.
+ * Provides a factory method to create control adapter instances.
+ *
+ * @template TTarget - The target ID (e.g., 'postgres', 'mysql')
+ */
+export interface SqlControlAdapterDescriptor<TTarget extends string = string> {
+  /**
+   * Creates a SQL control adapter instance for control-plane operations.
+   */
+  create(): SqlControlAdapter<TTarget>;
+}

package/src/core/descriptor.ts

@@ -0,0 +1,33 @@
+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';
+
+/**
+ * SQL family descriptor implementation.
+ * Provides the SQL family hook and factory method.
+ */
+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 {
+    // 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.
+    return createSqlFamilyInstance({
+      target: stack.target,
+      adapter: stack.adapter,
+      extensionPacks: stack.extensionPacks,
+    });
+  }
+}