@prisma-next/family-sql 0.14.0-dev.49 → 0.14.0-dev.50

package/dist/contract-to-schema-ir-S-evq8E6.mjs

@@ -1,264 +0,0 @@
-import { assertUniqueCodecOwner } from "@prisma-next/framework-components/control";
-import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
-import { ifDefined } from "@prisma-next/utils/defined";
-import { StorageTable, isStorageTypeInstance } from "@prisma-next/sql-contract/types";
-//#region src/core/assembly.ts
-function hasCodecControlHooks(descriptor) {
-	if (typeof descriptor !== "object" || descriptor === null) return false;
-	const hooks = descriptor.types?.codecTypes?.controlPlaneHooks;
-	return hooks !== null && hooks !== void 0 && typeof hooks === "object";
-}
-function extractCodecControlHooks(descriptors) {
-	const hooks = /* @__PURE__ */ new Map();
-	const owners = /* @__PURE__ */ new Map();
-	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;
-}
-//#endregion
-//#region src/core/migrations/contract-to-schema-ir.ts
-function convertColumn(name, column, storageTypes, expandNativeType, renderDefault) {
-	const resolved = resolveColumnTypeMetadata(column, storageTypes);
-	const baseNativeType = expandNativeType ? expandNativeType({
-		nativeType: resolved.nativeType,
-		codecId: resolved.codecId,
-		...ifDefined("typeParams", resolved.typeParams)
-	}) : resolved.nativeType;
-	return {
-		name,
-		nativeType: column.many ? `${baseNativeType}[]` : baseNativeType,
-		nullable: column.nullable,
-		...ifDefined("default", column.default != null && renderDefault ? renderDefault(column.default, column) : void 0)
-	};
-}
-function resolveColumnTypeMetadata(column, storageTypes) {
-	if (!column.typeRef) return column;
-	const referenced = storageTypes[column.typeRef];
-	if (!referenced) throw new Error(`Column references storage type "${column.typeRef}" but it is not defined in storage.types.`);
-	if (isStorageTypeInstance(referenced)) return {
-		codecId: referenced.codecId,
-		nativeType: referenced.nativeType,
-		typeParams: referenced.typeParams
-	};
-	throw new Error(`Storage type "${column.typeRef}" has an unknown polymorphic kind; expected a codec-typed StorageTypeInstance.`);
-}
-/**
-* Resolves a `ValueSetRef` to its permitted values from the contract storage.
-*
-* Throws when the referenced namespace or value-set is absent — this indicates
-* the contract was built incorrectly (the check and the value-set must be
-* co-emitted by the lowering step). Used by `convertCheck` (schema-IR
-* projection), `verifyCheckConstraints` (verification), and
-* `checkConstraintPlanCallStrategy` (migration planning) so all three agree on
-* the resolved values and the error behavior on a missing reference.
-*/
-function allStrings(values) {
-	return values.every((value) => typeof value === "string");
-}
-function resolveValueSetValues(ref, storage, contextLabel) {
-	const ns = storage.namespaces[ref.namespaceId];
-	if (!ns) throw new Error(`resolveValueSetValues: namespace "${ref.namespaceId}" not found in storage (${contextLabel})`);
-	const valueSet = ns.entries.valueSet?.[ref.entityName];
-	if (!valueSet) throw new Error(`resolveValueSetValues: value-set "${ref.entityName}" not found in namespace "${ref.namespaceId}" (${contextLabel})`);
-	const values = valueSet.values;
-	if (!allStrings(values)) throw new Error(`resolveValueSetValues: value-set "${ref.entityName}" in namespace "${ref.namespaceId}" has a non-string value; numeric-enum CHECK constraints are not yet supported (${contextLabel})`);
-	return values;
-}
-/**
-* Projects a `CheckConstraint` IR into an `SqlCheckConstraintIRInput` by
-* resolving the permitted values from the storage value-set it references.
-*
-* The `CheckConstraint.valueSet` ref points to
-* `storage.namespaces[namespaceId].entries.valueSet[name]`. The resolved
-* values are lifted directly from `StorageValueSet.values` so verification
-* compares value sets, not SQL predicate strings.
-*
-* Throws if the referenced namespace or value-set is absent — this
-* indicates the contract was built incorrectly (the check and the
-* value-set must be co-emitted by the lowering step).
-*/
-function convertCheck(check, storage) {
-	const permittedValues = resolveValueSetValues(check.valueSet, storage, `check "${check.name}"`);
-	return {
-		name: check.name,
-		column: check.column,
-		permittedValues
-	};
-}
-function convertUnique(unique) {
-	return {
-		columns: unique.columns,
-		...ifDefined("name", unique.name)
-	};
-}
-function convertIndex(index) {
-	return {
-		columns: index.columns,
-		unique: false,
-		...ifDefined("name", index.name)
-	};
-}
-function convertForeignKey(fk) {
-	return {
-		columns: fk.source.columns,
-		referencedTable: fk.target.tableName,
-		referencedSchema: fk.target.namespaceId,
-		referencedColumns: fk.target.columns,
-		...ifDefined("name", fk.name),
-		...ifDefined("onDelete", fk.onDelete),
-		...ifDefined("onUpdate", fk.onUpdate)
-	};
-}
-function convertTable(name, table, storageTypes, expandNativeType, renderDefault, storage) {
-	const columns = {};
-	for (const [colName, colDef] of Object.entries(table.columns)) columns[colName] = convertColumn(colName, colDef, storageTypes, expandNativeType, renderDefault);
-	const satisfiedIndexColumns = new Set([
-		...table.indexes.map((idx) => idx.columns.join(",")),
-		...table.uniques.map((unique) => unique.columns.join(",")),
-		...table.primaryKey ? [table.primaryKey.columns.join(",")] : []
-	]);
-	const fkBackingIndexes = [];
-	for (const fk of table.foreignKeys) {
-		if (fk.index === false) continue;
-		const key = fk.source.columns.join(",");
-		if (satisfiedIndexColumns.has(key)) continue;
-		fkBackingIndexes.push({
-			columns: fk.source.columns,
-			unique: false,
-			name: defaultIndexName(name, fk.source.columns)
-		});
-		satisfiedIndexColumns.add(key);
-	}
-	const checks = table.checks && table.checks.length > 0 ? table.checks.map((c) => convertCheck(c, storage)) : void 0;
-	return {
-		name,
-		columns,
-		...ifDefined("primaryKey", table.primaryKey),
-		foreignKeys: table.foreignKeys.filter((fk) => fk.constraint !== false).map(convertForeignKey),
-		uniques: table.uniques.map(convertUnique),
-		indexes: [...table.indexes.map(convertIndex), ...fkBackingIndexes],
-		...ifDefined("checks", checks)
-	};
-}
-/**
-* Detects destructive changes between two contract storages.
-*
-* The additive-only planner silently ignores removals (tables, columns).
-* This function detects those removals so callers can report them as conflicts
-* rather than silently producing an empty plan.
-*
-* Returns an empty array if no destructive changes are found.
-*/
-function detectDestructiveChanges(from, to) {
-	if (!from) return [];
-	const hasOwn = (value, key) => Object.hasOwn(value, key);
-	const conflicts = [];
-	const namespaceIds = [...new Set([...Object.keys(from.namespaces), ...Object.keys(to.namespaces)])].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-	for (const namespaceId of namespaceIds) {
-		const fromNs = from.namespaces[namespaceId];
-		const toNs = to.namespaces[namespaceId];
-		const fromTables = fromNs?.entries.table;
-		if (!fromTables) continue;
-		for (const tableName of Object.keys(fromTables)) {
-			const toTableRaw = toNs?.entries.table?.[tableName];
-			if (!StorageTable.is(toTableRaw)) {
-				conflicts.push({
-					kind: "tableRemoved",
-					summary: `Table "${tableName}" was removed`
-				});
-				continue;
-			}
-			const toTable = toTableRaw;
-			const fromTableRaw = fromTables[tableName];
-			if (!StorageTable.is(fromTableRaw)) continue;
-			const fromTable = fromTableRaw;
-			for (const columnName of Object.keys(fromTable.columns)) if (!hasOwn(toTable.columns, columnName)) conflicts.push({
-				kind: "columnRemoved",
-				summary: `Column "${tableName}"."${columnName}" was removed`
-			});
-		}
-	}
-	return conflicts;
-}
-/**
-* Converts a `Contract` to `SqlSchemaIR`.
-*
-* Reads `contract.storage` for tables and `contract.storage.types` for type
-* annotations. Storage-type annotations are written under
-* `options.annotationNamespace`.
-*
-* Drops codec metadata (`codecId`, `typeRef`) since the schema IR only represents
-* structural information. When `expandNativeType` is provided, parameterized types
-* are expanded (e.g. `character` + `{ length: 36 }` → `character(36)`) so the
-* resulting IR compares correctly against the "to" contract during planning.
-*
-* Returns an empty schema IR when `contract` is `null` (new project).
-*/
-/**
-* Converts the tables of a single namespace into a `SqlSchemaIR`, keyed by
-* table name within that namespace. Unlike {@link contractToSchemaIR}, which
-* flattens every namespace's tables into one bare-keyed record (and throws on a
-* cross-namespace name collision), this scopes the table iteration to one
-* namespace so the same table name can exist in two schemas.
-*
-* The full `storage` is still passed to `convertTable`, so value-set / enum /
-* type resolution that legitimately spans namespaces is unaffected. Foreign
-* keys are built purely from the FK descriptor (`fk.target`), so cross-namespace
-* FKs survive per-namespace conversion. The `annotations` block (storage-type
-* derived) is omitted here — the per-namespace tree consumer reads only the
-* per-table fields.
-*/
-function contractNamespaceToSchemaIR(storage, namespaceId, options) {
-	if (options.annotationNamespace.length === 0) throw new Error("annotationNamespace must be a non-empty string");
-	const namespace = storage.namespaces[namespaceId];
-	if (!namespace) return { tables: {} };
-	const storageTypes = { ...storage.types ?? {} };
-	const tables = {};
-	for (const [tableName, tableDefRaw] of Object.entries(namespace.entries.table ?? {})) {
-		StorageTable.assert(tableDefRaw, `namespaces.${namespaceId}.entries.table.${tableName}`);
-		tables[tableName] = convertTable(tableName, tableDefRaw, storageTypes, options.expandNativeType, options.renderDefault, storage);
-	}
-	return { tables };
-}
-function contractToSchemaIR(contract, options) {
-	if (options.annotationNamespace.length === 0) throw new Error("annotationNamespace must be a non-empty string");
-	if (!contract) return { tables: {} };
-	const storage = contract.storage;
-	const storageTypes = { ...storage.types ?? {} };
-	const tables = {};
-	for (const ns of Object.values(storage.namespaces)) for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table ?? {})) {
-		StorageTable.assert(tableDefRaw, `namespaces.${ns.id}.entries.table.${tableName}`);
-		const tableDef = tableDefRaw;
-		if (tables[tableName] !== void 0) throw new Error(`contractToSchemaIR: duplicate SQL table name "${tableName}" across namespaces (ambiguous for flat SqlSchemaIR.tables).`);
-		tables[tableName] = convertTable(tableName, tableDef, storageTypes, options.expandNativeType, options.renderDefault, storage);
-	}
-	return {
-		tables,
-		...ifDefined("annotations", deriveAnnotations(storage, options.annotationNamespace, options.resolveEnumNamespaceSchema))
-	};
-}
-function deriveAnnotations(storage, annotationNamespace, _resolveEnumNamespaceSchema) {
-	const storageTypes = {};
-	for (const typeInstance of Object.values(storage.types ?? {})) if (isStorageTypeInstance(typeInstance)) storageTypes[typeInstance.nativeType] = typeInstance;
-	const envelope = { ...Object.keys(storageTypes).length > 0 ? { storageTypes } : {} };
-	if (Object.keys(envelope).length === 0) return void 0;
-	return { [annotationNamespace]: envelope };
-}
-//#endregion
-export { extractCodecControlHooks as a, resolveValueSetValues as i, contractToSchemaIR as n, detectDestructiveChanges as r, contractNamespaceToSchemaIR as t };
-
-//# sourceMappingURL=contract-to-schema-ir-S-evq8E6.mjs.map

package/dist/contract-to-schema-ir-S-evq8E6.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-to-schema-ir-S-evq8E6.mjs","names":["d"],"sources":["../src/core/assembly.ts","../src/core/migrations/contract-to-schema-ir.ts"],"sourcesContent":["import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport { assertUniqueCodecOwner } from '@prisma-next/framework-components/control';\nimport type { CodecControlHooks } from './migrations/types';\n\ntype CodecControlHooksMap = Record<string, CodecControlHooks>;\n\nfunction hasCodecControlHooks(descriptor: unknown): descriptor is {\n  readonly id: string;\n  readonly types: {\n    readonly codecTypes: {\n      readonly controlPlaneHooks: CodecControlHooksMap;\n    };\n  };\n} {\n  if (typeof descriptor !== 'object' || descriptor === null) {\n    return false;\n  }\n  const d = descriptor as { types?: { codecTypes?: { controlPlaneHooks?: unknown } } };\n  const hooks = d.types?.codecTypes?.controlPlaneHooks;\n  return hooks !== null && hooks !== undefined && typeof hooks === 'object';\n}\n\nexport function extractCodecControlHooks(\n  descriptors: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>,\n): Map<string, CodecControlHooks> {\n  const hooks = new Map<string, CodecControlHooks>();\n  const owners = new Map<string, string>();\n\n  for (const descriptor of descriptors) {\n    if (typeof descriptor !== 'object' || descriptor === null) {\n      continue;\n    }\n    if (!hasCodecControlHooks(descriptor)) {\n      continue;\n    }\n    const controlPlaneHooks = descriptor.types.codecTypes.controlPlaneHooks;\n    for (const [codecId, hook] of Object.entries(controlPlaneHooks)) {\n      assertUniqueCodecOwner({\n        codecId,\n        owners,\n        descriptorId: descriptor.id,\n        entityLabel: 'control hooks',\n        entityOwnershipLabel: 'owner',\n      });\n      hooks.set(codecId, hook);\n      owners.set(codecId, descriptor.id);\n    }\n  }\n\n  return hooks;\n}\n","import type { ColumnDefault, Contract, JsonValue } from '@prisma-next/contract/types';\nimport type { MigrationPlannerConflict } from '@prisma-next/framework-components/control';\nimport {\n  type CheckConstraint,\n  type ForeignKey,\n  type Index,\n  isStorageTypeInstance,\n  type SqlStorage,\n  type StorageColumn,\n  StorageTable,\n  type StorageTypeInstance,\n  type UniqueConstraint,\n} from '@prisma-next/sql-contract/types';\nimport { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';\nimport type {\n  SqlAnnotations,\n  SqlCheckConstraintIRInput,\n  SqlColumnIR,\n  SqlForeignKeyIR,\n  SqlIndexIR,\n  SqlSchemaIR,\n  SqlTableIR,\n  SqlUniqueIR,\n} from '@prisma-next/sql-schema-ir/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\n\n/**\n * Target-specific callback that expands a column's base `nativeType` and optional\n * `typeParams` into the fully-qualified type string used by the database\n * (e.g. `character` + `{ length: 36 }` → `character(36)`).\n *\n * This lives in the family layer as a callback rather than importing a concrete\n * implementation because each target (Postgres, MySQL, SQLite, …) has its own\n * parameterization syntax. The target wires its expander when calling\n * `contractToSchemaIR`, keeping the family layer target-agnostic.\n */\nexport type NativeTypeExpander = (input: {\n  readonly nativeType: string;\n  readonly codecId?: string;\n  readonly typeParams?: Record<string, unknown>;\n}) => string;\n\n/**\n * Target-specific callback that renders a `ColumnDefault` into the raw SQL literal\n * string stored in `SqlColumnIR.default`.\n *\n * Default value serialization is target-specific (quoting, casting, type syntax vary\n * between Postgres, MySQL, SQLite, …). This callback follows the same IoC pattern as\n * `NativeTypeExpander`: the target provides its renderer when calling\n * `contractToSchemaIR`, keeping the family layer target-agnostic.\n */\nexport type DefaultRenderer = (def: ColumnDefault, column: StorageColumn) => string;\n\n/**\n * Target-supplied callback that resolves a contract namespace to the live\n * database schema its enums are stored under.\n *\n * The projected enum annotations are nested by schema\n * (`storageTypes[schema][nativeType]`) so two namespaces holding an enum with\n * the same native type resolve to distinct live-database types. Mapping a\n * namespace to its DDL schema is target-specific (Postgres schemas;\n * SQLite/MySQL differ), so the target injects it here rather than the family\n * importing a concrete `ddlSchemaName`. This keeps the family layer\n * target-agnostic while the projection nests under the same schema the\n * target's read side (`readExistingEnumValues`) looks up.\n */\nexport type EnumNamespaceSchemaResolver = (storage: SqlStorage, namespaceId: string) => string;\n\nfunction convertColumn(\n  name: string,\n  column: StorageColumn,\n  storageTypes: ResolvedStorageTypes,\n  expandNativeType: NativeTypeExpander | undefined,\n  renderDefault: DefaultRenderer | undefined,\n): SqlColumnIR {\n  // Resolve `typeRef` so columns that delegate their `nativeType`/`codecId`/\n  // `typeParams` to a named `storage.types` entry expand the same way as\n  // columns that inline those fields. Without this resolution, a\n  // `typeRef`-based column like `post.embedding → Embedding1536` would\n  // render as the bare `\"vector\"` (dropping the `length` parameter), while\n  // `verify-sql-schema.ts`'s `renderExpectedNativeType` resolves the\n  // typeRef and produces `\"vector(1536)\"` — making diffs on the same\n  // contract falsely report a `type_mismatch`.\n  const resolved = resolveColumnTypeMetadata(column, storageTypes);\n  const baseNativeType = expandNativeType\n    ? expandNativeType({\n        nativeType: resolved.nativeType,\n        codecId: resolved.codecId,\n        ...ifDefined('typeParams', resolved.typeParams),\n      })\n    : resolved.nativeType;\n  const nativeType = column.many ? `${baseNativeType}[]` : baseNativeType;\n  return {\n    name,\n    nativeType,\n    nullable: column.nullable,\n    ...ifDefined(\n      'default',\n      column.default != null && renderDefault ? renderDefault(column.default, column) : undefined,\n    ),\n  };\n}\n\ntype ResolvedStorageTypes = Readonly<Record<string, StorageTypeInstance>>;\n\nfunction resolveColumnTypeMetadata(\n  column: StorageColumn,\n  storageTypes: ResolvedStorageTypes,\n): Pick<StorageColumn, 'codecId' | 'nativeType' | 'typeParams'> {\n  if (!column.typeRef) {\n    return column;\n  }\n  const referenced = storageTypes[column.typeRef];\n  if (!referenced) {\n    throw new Error(\n      `Column references storage type \"${column.typeRef}\" but it is not defined in storage.types.`,\n    );\n  }\n  if (isStorageTypeInstance(referenced)) {\n    return {\n      codecId: referenced.codecId,\n      nativeType: referenced.nativeType,\n      typeParams: referenced.typeParams,\n    };\n  }\n  throw new Error(\n    `Storage type \"${column.typeRef}\" has an unknown polymorphic kind; expected a codec-typed StorageTypeInstance.`,\n  );\n}\n\n/**\n * Resolves a `ValueSetRef` to its permitted values from the contract storage.\n *\n * Throws when the referenced namespace or value-set is absent — this indicates\n * the contract was built incorrectly (the check and the value-set must be\n * co-emitted by the lowering step). Used by `convertCheck` (schema-IR\n * projection), `verifyCheckConstraints` (verification), and\n * `checkConstraintPlanCallStrategy` (migration planning) so all three agree on\n * the resolved values and the error behavior on a missing reference.\n */\nfunction allStrings(values: readonly JsonValue[]): values is readonly string[] {\n  return values.every((value) => typeof value === 'string');\n}\n\nexport function resolveValueSetValues(\n  ref: { readonly namespaceId: string; readonly entityName: string },\n  storage: SqlStorage,\n  contextLabel: string,\n): readonly string[] {\n  const ns = storage.namespaces[ref.namespaceId];\n  if (!ns) {\n    throw new Error(\n      `resolveValueSetValues: namespace \"${ref.namespaceId}\" not found in storage (${contextLabel})`,\n    );\n  }\n  const valueSet = ns.entries.valueSet?.[ref.entityName];\n  if (!valueSet) {\n    throw new Error(\n      `resolveValueSetValues: value-set \"${ref.entityName}\" not found in namespace \"${ref.namespaceId}\" (${contextLabel})`,\n    );\n  }\n  // Only TEXT enums ship a CHECK-constraint round-trip in this slice. A\n  // non-string value-set is a numeric enum, whose CHECK rendering/verification\n  // is future work; fail loudly rather than emit a wrong numeric-as-text check.\n  const values = valueSet.values;\n  if (!allStrings(values)) {\n    throw new Error(\n      `resolveValueSetValues: value-set \"${ref.entityName}\" in namespace \"${ref.namespaceId}\" has a non-string value; numeric-enum CHECK constraints are not yet supported (${contextLabel})`,\n    );\n  }\n  return values;\n}\n\n/**\n * Projects a `CheckConstraint` IR into an `SqlCheckConstraintIRInput` by\n * resolving the permitted values from the storage value-set it references.\n *\n * The `CheckConstraint.valueSet` ref points to\n * `storage.namespaces[namespaceId].entries.valueSet[name]`. The resolved\n * values are lifted directly from `StorageValueSet.values` so verification\n * compares value sets, not SQL predicate strings.\n *\n * Throws if the referenced namespace or value-set is absent — this\n * indicates the contract was built incorrectly (the check and the\n * value-set must be co-emitted by the lowering step).\n */\nfunction convertCheck(check: CheckConstraint, storage: SqlStorage): SqlCheckConstraintIRInput {\n  const permittedValues = resolveValueSetValues(check.valueSet, storage, `check \"${check.name}\"`);\n  return {\n    name: check.name,\n    column: check.column,\n    permittedValues,\n  };\n}\n\nfunction convertUnique(unique: UniqueConstraint): SqlUniqueIR {\n  return {\n    columns: unique.columns,\n    ...ifDefined('name', unique.name),\n  };\n}\n\nfunction convertIndex(index: Index): SqlIndexIR {\n  return {\n    columns: index.columns,\n    unique: false,\n    ...ifDefined('name', index.name),\n  };\n}\n\nfunction convertForeignKey(fk: ForeignKey): SqlForeignKeyIR {\n  return {\n    columns: fk.source.columns,\n    referencedTable: fk.target.tableName,\n    referencedSchema: fk.target.namespaceId,\n    referencedColumns: fk.target.columns,\n    ...ifDefined('name', fk.name),\n    ...ifDefined('onDelete', fk.onDelete),\n    ...ifDefined('onUpdate', fk.onUpdate),\n  };\n}\n\nfunction convertTable(\n  name: string,\n  table: StorageTable,\n  storageTypes: ResolvedStorageTypes,\n  expandNativeType: NativeTypeExpander | undefined,\n  renderDefault: DefaultRenderer | undefined,\n  storage: SqlStorage,\n): SqlTableIR {\n  const columns: Record<string, SqlColumnIR> = {};\n  for (const [colName, colDef] of Object.entries(table.columns)) {\n    columns[colName] = convertColumn(\n      colName,\n      colDef,\n      storageTypes,\n      expandNativeType,\n      renderDefault,\n    );\n  }\n\n  const satisfiedIndexColumns = new Set([\n    ...table.indexes.map((idx) => idx.columns.join(',')),\n    ...table.uniques.map((unique) => unique.columns.join(',')),\n    ...(table.primaryKey ? [table.primaryKey.columns.join(',')] : []),\n  ]);\n  const fkBackingIndexes: SqlIndexIR[] = [];\n  for (const fk of table.foreignKeys) {\n    if (fk.index === false) continue;\n    const key = fk.source.columns.join(',');\n    if (satisfiedIndexColumns.has(key)) continue;\n    fkBackingIndexes.push({\n      columns: fk.source.columns,\n      unique: false,\n      name: defaultIndexName(name, fk.source.columns),\n    });\n    satisfiedIndexColumns.add(key);\n  }\n\n  const checks: SqlCheckConstraintIRInput[] | undefined =\n    table.checks && table.checks.length > 0\n      ? table.checks.map((c) => convertCheck(c, storage))\n      : undefined;\n\n  return {\n    name,\n    columns,\n    ...ifDefined('primaryKey', table.primaryKey),\n    foreignKeys: table.foreignKeys.filter((fk) => fk.constraint !== false).map(convertForeignKey),\n    uniques: table.uniques.map(convertUnique),\n    indexes: [...table.indexes.map(convertIndex), ...fkBackingIndexes],\n    ...ifDefined('checks', checks),\n  };\n}\n\n/**\n * Detects destructive changes between two contract storages.\n *\n * The additive-only planner silently ignores removals (tables, columns).\n * This function detects those removals so callers can report them as conflicts\n * rather than silently producing an empty plan.\n *\n * Returns an empty array if no destructive changes are found.\n */\nexport function detectDestructiveChanges(\n  from: SqlStorage | null,\n  to: SqlStorage,\n): readonly MigrationPlannerConflict[] {\n  if (!from) return [];\n\n  const hasOwn = (value: object, key: string): boolean => Object.hasOwn(value, key);\n\n  const conflicts: MigrationPlannerConflict[] = [];\n\n  const namespaceIds = [\n    ...new Set([...Object.keys(from.namespaces), ...Object.keys(to.namespaces)]),\n  ].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));\n\n  for (const namespaceId of namespaceIds) {\n    const fromNs = from.namespaces[namespaceId];\n    const toNs = to.namespaces[namespaceId];\n    const fromTables = fromNs?.entries.table;\n    if (!fromTables) continue;\n\n    for (const tableName of Object.keys(fromTables)) {\n      const toTableRaw = toNs?.entries.table?.[tableName];\n      if (!StorageTable.is(toTableRaw)) {\n        conflicts.push({\n          kind: 'tableRemoved',\n          summary: `Table \"${tableName}\" was removed`,\n        });\n        continue;\n      }\n      const toTable = toTableRaw;\n\n      const fromTableRaw = fromTables[tableName];\n      if (!StorageTable.is(fromTableRaw)) continue;\n      const fromTable = fromTableRaw;\n\n      for (const columnName of Object.keys(fromTable.columns)) {\n        if (!hasOwn(toTable.columns, columnName)) {\n          conflicts.push({\n            kind: 'columnRemoved',\n            summary: `Column \"${tableName}\".\"${columnName}\" was removed`,\n          });\n        }\n      }\n    }\n  }\n\n  return conflicts;\n}\n\nexport interface ContractToSchemaIROptions {\n  readonly annotationNamespace: string;\n  readonly expandNativeType?: NativeTypeExpander;\n  readonly renderDefault?: DefaultRenderer;\n  /**\n   * Target-supplied resolver mapping a namespace to the live database schema\n   * its enums are stored under. When provided (Postgres), namespace-scoped\n   * enums are nested by that schema in `enumTypes` so the projection matches\n   * the target's `readExistingEnumValues` lookup. Targets without\n   * schema-scoped enum storage (SQLite) omit it; enums are absent there.\n   */\n  readonly resolveEnumNamespaceSchema?: EnumNamespaceSchemaResolver;\n}\n\n/**\n * Converts a `Contract` to `SqlSchemaIR`.\n *\n * Reads `contract.storage` for tables and `contract.storage.types` for type\n * annotations. Storage-type annotations are written under\n * `options.annotationNamespace`.\n *\n * Drops codec metadata (`codecId`, `typeRef`) since the schema IR only represents\n * structural information. When `expandNativeType` is provided, parameterized types\n * are expanded (e.g. `character` + `{ length: 36 }` → `character(36)`) so the\n * resulting IR compares correctly against the \"to\" contract during planning.\n *\n * Returns an empty schema IR when `contract` is `null` (new project).\n */\n/**\n * Converts the tables of a single namespace into a `SqlSchemaIR`, keyed by\n * table name within that namespace. Unlike {@link contractToSchemaIR}, which\n * flattens every namespace's tables into one bare-keyed record (and throws on a\n * cross-namespace name collision), this scopes the table iteration to one\n * namespace so the same table name can exist in two schemas.\n *\n * The full `storage` is still passed to `convertTable`, so value-set / enum /\n * type resolution that legitimately spans namespaces is unaffected. Foreign\n * keys are built purely from the FK descriptor (`fk.target`), so cross-namespace\n * FKs survive per-namespace conversion. The `annotations` block (storage-type\n * derived) is omitted here — the per-namespace tree consumer reads only the\n * per-table fields.\n */\nexport function contractNamespaceToSchemaIR(\n  storage: SqlStorage,\n  namespaceId: string,\n  options: ContractToSchemaIROptions,\n): SqlSchemaIR {\n  if (options.annotationNamespace.length === 0) {\n    throw new Error('annotationNamespace must be a non-empty string');\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (!namespace) {\n    return { tables: {} };\n  }\n  const storageTypes: ResolvedStorageTypes = { ...(storage.types ?? {}) };\n  const tables: Record<string, SqlTableIR> = {};\n  for (const [tableName, tableDefRaw] of Object.entries(namespace.entries.table ?? {})) {\n    StorageTable.assert(tableDefRaw, `namespaces.${namespaceId}.entries.table.${tableName}`);\n    tables[tableName] = convertTable(\n      tableName,\n      tableDefRaw,\n      storageTypes,\n      options.expandNativeType,\n      options.renderDefault,\n      storage,\n    );\n  }\n  return { tables };\n}\n\nexport function contractToSchemaIR(\n  contract: Contract<SqlStorage> | null,\n  options: ContractToSchemaIROptions,\n): SqlSchemaIR {\n  if (options.annotationNamespace.length === 0) {\n    throw new Error('annotationNamespace must be a non-empty string');\n  }\n\n  if (!contract) {\n    return { tables: {} };\n  }\n\n  const storage = contract.storage;\n  const storageTypes: ResolvedStorageTypes = { ...(storage.types ?? {}) };\n  const tables: Record<string, SqlTableIR> = {};\n  for (const ns of Object.values(storage.namespaces)) {\n    for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table ?? {})) {\n      StorageTable.assert(tableDefRaw, `namespaces.${ns.id}.entries.table.${tableName}`);\n      const tableDef = tableDefRaw;\n      if (tables[tableName] !== undefined) {\n        throw new Error(\n          `contractToSchemaIR: duplicate SQL table name \"${tableName}\" across namespaces (ambiguous for flat SqlSchemaIR.tables).`,\n        );\n      }\n      tables[tableName] = convertTable(\n        tableName,\n        tableDef,\n        storageTypes,\n        options.expandNativeType,\n        options.renderDefault,\n        storage,\n      );\n    }\n  }\n\n  const annotations = deriveAnnotations(\n    storage,\n    options.annotationNamespace,\n    options.resolveEnumNamespaceSchema,\n  );\n\n  return {\n    tables,\n    ...ifDefined('annotations', annotations),\n  };\n}\n\nfunction deriveAnnotations(\n  storage: SqlStorage,\n  annotationNamespace: string,\n  _resolveEnumNamespaceSchema: EnumNamespaceSchemaResolver | undefined,\n): SqlAnnotations | undefined {\n  const storageTypes: Record<string, StorageTypeInstance> = {};\n\n  for (const typeInstance of Object.values(storage.types ?? {})) {\n    if (isStorageTypeInstance(typeInstance)) {\n      storageTypes[typeInstance.nativeType] = typeInstance;\n    }\n  }\n\n  const envelope = {\n    ...(Object.keys(storageTypes).length > 0 ? { storageTypes } : {}),\n  };\n  if (Object.keys(envelope).length === 0) return undefined;\n  return { [annotationNamespace]: envelope };\n}\n"],"mappings":"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"}

package/dist/control-adapter-DHYFuOBy.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"control-adapter-DHYFuOBy.d.mts","names":[],"sources":["../src/core/control-adapter.ts"],"mappings":";;;;;;;;;;AAuBA;;;;;UAAiB,OAAA;EACf,KAAA,CAAM,GAAA,EAAK,WAAA,GAAc,OAAA,EAAS,OAAA,EAAS,cAAA,YAA0B,gBAAA;AAAA;;;;;;;UAStD,qBAAA,SAA8B,OAAA;EAC7C,qBAAA,CACE,GAAA,EAAK,WAAA,GAAc,OAAA,EACnB,OAAA,GAAU,cAAA,YACT,OAAA,CAAQ,iBAAA;AAAA;AAb0E;AASvF;;;;;AATuF,UAsBtE,iBAAA,0CACP,sBAAA,QAA8B,OAAA,GACpC,qBAAA;EAXS;;;;;;;;;;;;;;;EA2BX,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,WACC,OAAA,CAAQ,oBAAA;EArBI;;;;;;;EA8Bf,cAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,IAChC,OAAA,CAAQ,WAAA,SAAoB,oBAAA;EADI;;;;EAOnC,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,YACC,OAAA,UAAiB,iBAAA;EAFe;;;;;;EAUnC,YAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,WAAA;IAAA,SACW,WAAA;IAAA,SACA,WAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EA0BO;;;;;;EAlBV,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,WAAA;IAAA,SACW,WAAA;IAAA,SACA,WAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EAgFsC;;;;;;;EAvEzC,YAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,YAAA,UACA,WAAA;IAAA,SACW,WAAA;IAAA,SACA,WAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EAxEgC;;;;;;EAgFnC,gBAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,KAAA;IAAA,SACW,MAAA;IAAA,SACA,IAAA;IAAA,SACA,EAAA;IAAA,SACA,aAAA;IAAA,SACA,aAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EAvEgC;;;;;;;;;;;;;;;;;EA0FnC,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,QAAA,YACA,MAAA,YACC,OAAA,CAAQ,eAAA;EAnET;;;;;EAAA,SA0EO,gBAAA,GAAmB,iBAAA;EAnEzB;;;;;EAAA,SA0EM,mBAAA,GAAsB,oBAAA;EA9D7B;;;;EAoEF,4BAAA,aAAyC,OAAA;EA9DtC;;;;EAoEH,0BAAA,aAAuC,OAAA;AAAA;;;;;;;UASxB,2BAAA;EA1DZ;;;;;;EAiEH,MAAA,CAAO,KAAA,EAAO,YAAA,QAAoB,OAAA,IAAW,iBAAA,CAAkB,OAAA;AAAA"}

package/dist/sql-schema-diff-6z36dZt6.d.mts

@@ -1,105 +0,0 @@
-import { ColumnDefault, Contract } from "@prisma-next/contract/types";
-import { OperationContext, VerifyDatabaseSchemaResult } from "@prisma-next/framework-components/control";
-import { SqlStorage } from "@prisma-next/sql-contract/types";
-import { SqlSchemaIR, SqlSchemaIRNode } from "@prisma-next/sql-schema-ir/types";
-import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
-
-//#region src/core/diff/sql-schema-diff.d.ts
-/**
- * Function type for normalizing raw database default expressions into ColumnDefault.
- * Target-specific implementations handle database dialect differences.
- */
-type DefaultNormalizer = (rawDefault: string, nativeType: string) => ColumnDefault | undefined;
-/**
- * Function type for normalizing schema native types to canonical form for comparison.
- * Target-specific implementations handle dialect-specific type name variations
- * (e.g., Postgres 'varchar' → 'character varying', 'timestamptz' normalization).
- */
-type NativeTypeNormalizer = (nativeType: string) => string;
-/**
- * Options for the pure schema verification function.
- */
-interface VerifySqlSchemaOptions {
-  /** The validated SQL contract to verify against */
-  readonly contract: Contract<SqlStorage>;
-  /** The schema IR from introspection (or another source) */
-  readonly schema: SqlSchemaIR;
-  /** Whether to run in strict mode (detects extra tables/columns) */
-  readonly strict: boolean;
-  /** Optional operation context for metadata */
-  readonly context?: OperationContext;
-  /** Type metadata registry for codec consistency warnings */
-  readonly typeMetadataRegistry: ReadonlyMap<string, {
-    nativeType?: string;
-  }>;
-  /**
-   * Active framework components participating in this composition.
-   * All components must have matching familyId ('sql') and targetId.
-   */
-  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
-  /**
-   * Optional target-specific normalizer for raw database default expressions.
-   * When provided, schema defaults (raw strings) are normalized before comparison
-   * with contract defaults (ColumnDefault objects).
-   */
-  readonly normalizeDefault?: DefaultNormalizer;
-  /**
-   * Optional target-specific normalizer for schema native type names.
-   * When provided, schema native types are normalized before comparison
-   * with contract native types (e.g., Postgres 'varchar' → 'character varying').
-   */
-  readonly normalizeNativeType?: NativeTypeNormalizer;
-  /**
-   * When set, only the contract tables in these namespace ids are checked
-   * against `schema` (the matching actual namespace node). The full contract is
-   * still consulted for cross-namespace value-set / control-policy resolution.
-   * Used by the multi-schema verify, which pairs each contract namespace to its
-   * own actual node. Absent ⇒ all contract namespaces are checked against the
-   * single (flat) `schema` — the single-schema / SQLite path.
-   */
-  readonly restrictToNamespaceIds?: ReadonlySet<string>;
-}
-/**
- * Verifies that a SqlSchemaIR matches a Contract.
- *
- * This is a pure function that does NOT perform any database I/O.
- * It takes an already-introspected schema IR and compares it against
- * the contract requirements.
- *
- * @param options - Verification options
- * @returns VerifyDatabaseSchemaResult with verification tree and issues
- */
-declare function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabaseSchemaResult;
-/**
- * The single per-namespace-paired relational verify shared by the migration
- * planner and the family schema verify — there is exactly one such operation.
- *
- * Each contract namespace is paired to the introspected namespace node holding
- * the same DDL schema, then `verifySqlSchema` checks that namespace's tables
- * against the matching actual node (a contract table under `auth` is only ever
- * looked up in the `auth` actual node, so a multi-schema database no longer
- * reports tables in other schemas as missing). The full contract is passed every
- * time — `restrictToNamespaceIds` scopes only which tables are checked, so
- * cross-namespace value-set / control-policy resolution is unaffected.
- *
- * The DDL schema of each contract namespace is read from a single-namespace
- * expected projection (`buildExpectedSchema`), which both callers already build
- * the same way. Empty contract namespaces verify nothing and are skipped.
- * Single-schema (one namespace) and SQLite's flat schema are one pairing —
- * byte-identical to the prior per-node verify.
- */
-declare function verifySqlSchemaTree(options: {
-  readonly contract: Contract<SqlStorage>;
-  readonly actualSchema: SqlSchemaIRNode;
-  readonly buildExpectedSchema: (contract: Contract<SqlStorage>) => SqlSchemaIRNode;
-  readonly strict: boolean;
-  readonly typeMetadataRegistry: ReadonlyMap<string, {
-    nativeType?: string;
-  }>;
-  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
-  readonly normalizeDefault?: DefaultNormalizer;
-  readonly normalizeNativeType?: NativeTypeNormalizer;
-}): VerifyDatabaseSchemaResult;
-//#endregion
-export { verifySqlSchemaTree as a, verifySqlSchema as i, NativeTypeNormalizer as n, VerifySqlSchemaOptions as r, DefaultNormalizer as t };
-//# sourceMappingURL=sql-schema-diff-6z36dZt6.d.mts.map

package/dist/sql-schema-diff-6z36dZt6.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql-schema-diff-6z36dZt6.d.mts","names":[],"sources":["../src/core/diff/sql-schema-diff.ts"],"mappings":";;;;;;;;;;AA4EkB;KAHN,iBAAA,IACV,UAAA,UACA,UAAA,aACG,aAAa;;;;AAOoC;AAKtD;KALY,oBAAA,IAAwB,UAAkB;;;;UAKrC,sBAAA;EAQI;EAAA,SANV,QAAA,EAAU,QAAA,CAAS,UAAA;EAagB;EAAA,SAXnC,MAAA,EAAQ,WAAA;EAiBW;EAAA,SAfnB,MAAA;EA8ByB;EAAA,SA5BzB,OAAA,GAAU,gBAAA;EA4B0B;EAAA,SA1BpC,oBAAA,EAAsB,WAAA;IAAsB,UAAA;EAAA;EAN5C;;;;EAAA,SAWA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;EALnC;;;;;EAAA,SAWA,gBAAA,GAAmB,iBAAA;EAAnB;;;;;EAAA,SAMA,mBAAA,GAAsB,oBAAA;EASc;AAAA;AAa/C;;;;;;EAb+C,SAApC,sBAAA,GAAyB,WAAA;AAAA;AAawD;AAkyC5F;;;;;;;;;AAlyC4F,iBAA5E,eAAA,CAAgB,OAAA,EAAS,sBAAA,GAAyB,0BAA0B;;;;;;;;;;;;;;;;;;;iBAkyC5E,mBAAA,CAAoB,OAAA;EAAA,SACzB,QAAA,EAAU,QAAA,CAAS,UAAA;EAAA,SACnB,YAAA,EAAc,eAAA;EAAA,SACd,mBAAA,GAAsB,QAAA,EAAU,QAAA,CAAS,UAAA,MAAgB,eAAA;EAAA,SACzD,MAAA;EAAA,SACA,oBAAA,EAAsB,WAAA;IAAsB,UAAA;EAAA;EAAA,SAC5C,mBAAA,EAAqB,aAAA,CAAc,8BAAA;EAAA,SACnC,gBAAA,GAAmB,iBAAA;EAAA,SACnB,mBAAA,GAAsB,oBAAA;AAAA,IAC7B,0BAAA"}

package/dist/types-DBxrwN1d.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-DBxrwN1d.d.mts","names":[],"sources":["../src/core/migrations/types.ts"],"mappings":"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"}

package/src/core/diff/control-verify-emit.ts

@@ -1,46 +0,0 @@
-import type { ControlPolicy } from '@prisma-next/contract/types';
-import type {
-  SchemaIssue,
-  SchemaVerificationNode,
-  VerifierOutcome,
-} from '@prisma-next/framework-components/control';
-import { verifierDisposition } from './verifier-disposition';
-
-/**
- * Grades `issue` under `controlPolicy` and, unless suppressed, pushes both the
- * issue and a status-stamped verification node. Returns the resolved outcome so
- * the caller never re-grades the same issue.
- */
-export function emitIssueAndNodeUnderControlPolicy(
-  controlPolicy: ControlPolicy,
-  issue: SchemaIssue,
-  node: SchemaVerificationNode,
-  issues: SchemaIssue[],
-  nodes: SchemaVerificationNode[],
-): VerifierOutcome {
-  const disposition = verifierDisposition(controlPolicy, issue.kind);
-  if (disposition === 'suppress') {
-    return disposition;
-  }
-  issues.push(issue);
-  nodes.push({ ...node, status: disposition });
-  return disposition;
-}
-
-/**
- * Grades `issue` under `controlPolicy` and, unless suppressed, pushes the issue
- * (no verification node). Returns the resolved outcome so the caller maps it to
- * a node status itself without re-grading.
- */
-export function emitIssueUnderControlPolicy(
-  controlPolicy: ControlPolicy,
-  issue: SchemaIssue,
-  issues: SchemaIssue[],
-): VerifierOutcome {
-  const disposition = verifierDisposition(controlPolicy, issue.kind);
-  if (disposition === 'suppress') {
-    return disposition;
-  }
-  issues.push(issue);
-  return disposition;
-}