@prisma-next/family-sql 0.3.0-pr.99.6 → 0.4.0-dev.1

package/src/core/assembly.ts

@@ -1,189 +1,157 @@
+import type { AuthoringContributions } from '@prisma-next/framework-components/authoring';
+import type { Codec } from '@prisma-next/framework-components/codec';
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import { assertUniqueCodecOwner } from '@prisma-next/framework-components/control';
+import type { TypesImportSpec } from '@prisma-next/framework-components/emission';
 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);
-    }
-  }
+  CodecControlHooks,
+  ControlMutationDefaultFunctionEntry,
+  ControlMutationDefaultGeneratorDescriptor,
+  PslScalarTypeDescriptor,
+  SqlControlStaticContributions,
+} from './migrations/types';
+
+export interface SqlControlDescriptorWithContributions extends SqlControlStaticContributions {
+  readonly id: string;
+  readonly authoring?: AuthoringContributions;
+  readonly types?: {
+    readonly codecTypes?: {
+      readonly import?: TypesImportSpec;
+      readonly codecInstances?: ReadonlyArray<Codec>;
+      readonly typeImports?: ReadonlyArray<TypesImportSpec>;
+    };
+    readonly operationTypes?: { readonly import: TypesImportSpec };
+  };
+}
 
-  return registry;
+export interface AssembledControlMutationDefaultContributions {
+  readonly defaultFunctionRegistry: ReadonlyMap<string, ControlMutationDefaultFunctionEntry>;
+  readonly generatorDescriptors: readonly ControlMutationDefaultGeneratorDescriptor[];
 }
 
-/**
- * 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[] = [];
+export interface AssembledPslInterpretationContributions
+  extends AssembledControlMutationDefaultContributions {
+  readonly scalarTypeDescriptors: ReadonlyMap<string, PslScalarTypeDescriptor>;
+}
 
-  for (const descriptor of descriptors) {
-    const types = descriptor.types;
-    const codecTypes = types?.codecTypes;
-    if (codecTypes?.import) {
-      imports.push(codecTypes.import);
-    }
+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;
   }
-
-  return imports;
+  const d = descriptor as { types?: { codecTypes?: { controlPlaneHooks?: unknown } } };
+  const hooks = d.types?.codecTypes?.controlPlaneHooks;
+  return hooks !== null && hooks !== undefined && typeof hooks === 'object';
 }
 
-/**
- * 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[] = [];
+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) {
-    const types = descriptor.types;
-    const operationTypes = types?.operationTypes;
-    if (operationTypes?.import) {
-      imports.push(operationTypes.import);
+    if (typeof descriptor !== 'object' || descriptor === null) {
+      continue;
     }
-  }
-
-  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);
+    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;
 }
 
-/**
- * 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
+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 codecTypes = descriptor.types?.codecTypes;
-    if (!codecTypes?.parameterized) continue;
+    const contributions = descriptor.controlMutationDefaults?.();
+    if (!contributions) {
+      continue;
+    }
 
-    const parameterized: Record<string, TypeRenderer> = codecTypes.parameterized;
-    for (const [codecId, renderer] of Object.entries(parameterized)) {
-      const existingOwner = owners.get(codecId);
-      if (existingOwner !== undefined) {
+    for (const generatorDescriptor of contributions.generatorDescriptors) {
+      const owner = generatorOwners.get(generatorDescriptor.id);
+      if (owner) {
         throw new Error(
-          `Duplicate parameterized renderer for codecId "${codecId}". ` +
-            `Descriptor "${descriptor.id}" conflicts with "${existingOwner}". ` +
-            'Each codecId can only have one renderer.',
+          `Duplicate mutation default generator id "${generatorDescriptor.id}". Descriptor "${descriptor.id}" conflicts with "${owner}".`,
         );
       }
+      generatorMap.set(generatorDescriptor.id, generatorDescriptor);
+      generatorOwners.set(generatorDescriptor.id, descriptor.id);
+    }
 
-      renderers.set(codecId, normalizeRenderer(codecId, renderer));
-      owners.set(codecId, 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 renderers;
+  return {
+    defaultFunctionRegistry,
+    generatorDescriptors: Array.from(generatorMap.values()),
+  };
 }
 
-/**
- * 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[] = [];
+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 parameterizedImports = descriptor.types?.codecTypes?.parameterizedImports;
-    if (parameterizedImports) {
-      imports.push(...parameterizedImports);
+    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 imports;
+  return {
+    ...mutationDefaults,
+    scalarTypeDescriptors,
+  };
 }

package/src/core/authoring-field-presets.ts

@@ -0,0 +1,207 @@
+import type { AuthoringFieldNamespace } from '@prisma-next/framework-components/authoring';
+
+const CHARACTER_CODEC_ID = 'sql/char@1';
+const CHARACTER_NATIVE_TYPE = 'character';
+
+const nanoidOptionsArgument = {
+  kind: 'object',
+  optional: true,
+  properties: {
+    size: {
+      kind: 'number',
+      optional: true,
+      integer: true,
+      minimum: 2,
+      maximum: 255,
+    },
+  },
+} as const;
+
+export const sqlFamilyAuthoringFieldPresets = {
+  text: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'sql/text@1',
+      nativeType: 'text',
+    },
+  },
+  timestamp: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'sql/timestamp@1',
+      nativeType: 'timestamp',
+    },
+  },
+  createdAt: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'sql/timestamp@1',
+      nativeType: 'timestamp',
+      default: {
+        kind: 'function',
+        expression: 'CURRENT_TIMESTAMP',
+      },
+    },
+  },
+  uuid: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: CHARACTER_CODEC_ID,
+      nativeType: CHARACTER_NATIVE_TYPE,
+      typeParams: {
+        length: 36,
+      },
+    },
+  },
+  ulid: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: CHARACTER_CODEC_ID,
+      nativeType: CHARACTER_NATIVE_TYPE,
+      typeParams: {
+        length: 26,
+      },
+    },
+  },
+  nanoid: {
+    kind: 'fieldPreset',
+    args: [nanoidOptionsArgument],
+    output: {
+      codecId: CHARACTER_CODEC_ID,
+      nativeType: CHARACTER_NATIVE_TYPE,
+      typeParams: {
+        length: {
+          kind: 'arg',
+          index: 0,
+          path: ['size'],
+          default: 21,
+        },
+      },
+    },
+  },
+  cuid2: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: CHARACTER_CODEC_ID,
+      nativeType: CHARACTER_NATIVE_TYPE,
+      typeParams: {
+        length: 24,
+      },
+    },
+  },
+  ksuid: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: CHARACTER_CODEC_ID,
+      nativeType: CHARACTER_NATIVE_TYPE,
+      typeParams: {
+        length: 27,
+      },
+    },
+  },
+  id: {
+    uuidv4: {
+      kind: 'fieldPreset',
+      output: {
+        codecId: CHARACTER_CODEC_ID,
+        nativeType: CHARACTER_NATIVE_TYPE,
+        typeParams: {
+          length: 36,
+        },
+        executionDefault: {
+          kind: 'generator',
+          id: 'uuidv4',
+        },
+        id: true,
+      },
+    },
+    uuidv7: {
+      kind: 'fieldPreset',
+      output: {
+        codecId: CHARACTER_CODEC_ID,
+        nativeType: CHARACTER_NATIVE_TYPE,
+        typeParams: {
+          length: 36,
+        },
+        executionDefault: {
+          kind: 'generator',
+          id: 'uuidv7',
+        },
+        id: true,
+      },
+    },
+    ulid: {
+      kind: 'fieldPreset',
+      output: {
+        codecId: CHARACTER_CODEC_ID,
+        nativeType: CHARACTER_NATIVE_TYPE,
+        typeParams: {
+          length: 26,
+        },
+        executionDefault: {
+          kind: 'generator',
+          id: 'ulid',
+        },
+        id: true,
+      },
+    },
+    nanoid: {
+      kind: 'fieldPreset',
+      args: [nanoidOptionsArgument],
+      output: {
+        codecId: CHARACTER_CODEC_ID,
+        nativeType: CHARACTER_NATIVE_TYPE,
+        typeParams: {
+          length: {
+            kind: 'arg',
+            index: 0,
+            path: ['size'],
+            default: 21,
+          },
+        },
+        executionDefault: {
+          kind: 'generator',
+          id: 'nanoid',
+          params: {
+            size: {
+              kind: 'arg',
+              index: 0,
+              path: ['size'],
+            },
+          },
+        },
+        id: true,
+      },
+    },
+    cuid2: {
+      kind: 'fieldPreset',
+      output: {
+        codecId: CHARACTER_CODEC_ID,
+        nativeType: CHARACTER_NATIVE_TYPE,
+        typeParams: {
+          length: 24,
+        },
+        executionDefault: {
+          kind: 'generator',
+          id: 'cuid2',
+        },
+        id: true,
+      },
+    },
+    ksuid: {
+      kind: 'fieldPreset',
+      output: {
+        codecId: CHARACTER_CODEC_ID,
+        nativeType: CHARACTER_NATIVE_TYPE,
+        typeParams: {
+          length: 27,
+        },
+        executionDefault: {
+          kind: 'generator',
+          id: 'ksuid',
+        },
+        id: true,
+      },
+    },
+  },
+} as const satisfies AuthoringFieldNamespace;

package/src/core/authoring-type-constructors.ts

@@ -0,0 +1,17 @@
+import type { AuthoringTypeNamespace } from '@prisma-next/framework-components/authoring';
+
+export const sqlFamilyAuthoringTypes = {
+  sql: {
+    String: {
+      kind: 'typeConstructor',
+      args: [{ kind: 'number', name: 'length', integer: true, minimum: 1, maximum: 10485760 }],
+      output: {
+        codecId: 'sql/varchar@1',
+        nativeType: 'character varying',
+        typeParams: {
+          length: { kind: 'arg', index: 0 },
+        },
+      },
+    },
+  },
+} as const satisfies AuthoringTypeNamespace;

package/src/core/control-adapter.ts

@@ -1,8 +1,9 @@
 import type {
   ControlAdapterInstance,
   ControlDriverInstance,
-} from '@prisma-next/core-control-plane/types';
+} from '@prisma-next/framework-components/control';
 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.
@@ -12,13 +13,6 @@ import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
  */
 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.
    *
@@ -27,15 +21,29 @@ export interface SqlControlAdapter<TTarget extends string = string>
    * 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 contract - Optional contract 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,
+    contract?: 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,28 @@
+import type {
+  ControlFamilyDescriptor,
+  ControlStack,
+} from '@prisma-next/framework-components/control';
+import { sqlEmission } from '@prisma-next/sql-contract-emitter';
+import { sqlFamilyAuthoringFieldPresets } from './authoring-field-presets';
+import { sqlFamilyAuthoringTypes } from './authoring-type-constructors';
+import { createSqlFamilyInstance, type SqlControlFamilyInstance } from './control-instance';
+
+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 emission = sqlEmission;
+  readonly authoring = {
+    field: sqlFamilyAuthoringFieldPresets,
+    type: sqlFamilyAuthoringTypes,
+  } as const;
+
+  create<TTargetId extends string>(
+    stack: ControlStack<'sql', TTargetId>,
+  ): SqlControlFamilyInstance {
+    return createSqlFamilyInstance(stack);
+  }
+}