@prisma-next/family-sql 0.14.0-dev.9 → 0.14.0-dev.90

package/dist/schema-verify-W3r631Jh.mjs

@@ -0,0 +1,226 @@
+import { blindCast } from "@prisma-next/utils/casts";
+import { assertUniqueCodecOwner, dispositionForCategory } from "@prisma-next/framework-components/control";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { effectiveControlPolicy } from "@prisma-next/contract/types";
+import { isStorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { RelationalSchemaNodeKind } from "@prisma-next/sql-schema-ir/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/diff/verifier-disposition.ts
+/**
+* Classifies a codec `verifyType` hook finding into the target-neutral
+* categories the framework grades. A storage type is a named type instance
+* (e.g. a native enum); the only shape divergence it can carry is a change
+* to its value set, so a paired mismatch always classifies as `valueDrift`.
+*/
+function classifyStorageTypeDiffIssue(issue) {
+	if (issue.reason === "not-found") return "declaredMissing";
+	if (issue.reason === "not-expected") return "extraAuxiliary";
+	return "valueDrift";
+}
+function verifierDisposition(controlPolicy, issue) {
+	return dispositionForCategory(controlPolicy, classifyStorageTypeDiffIssue(issue));
+}
+//#endregion
+//#region src/core/diff/schema-verify.ts
+function issueNode(issue) {
+	const node = issue.expected ?? issue.actual;
+	if (node === void 0) return void 0;
+	return blindCast(node);
+}
+/**
+* Resolves an issue's framework-neutral {@link DiffSubjectGranularity} on
+* demand, from the issue's node's `nodeKind` via the target-provided
+* `granularityOf` map. The node carries only its `nodeKind` identity, never a
+* classification, and nothing is stamped onto the issue — every consumer
+* (the family verdict below, the framework aggregate's unclaimed-elements
+* sweep via {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable})
+* calls this the same way, resolved by the family/target that owns the node
+* vocabulary. `undefined` for an issue with no node.
+*/
+function classifyDiffSubjectGranularity(issue, granularityOf) {
+	const node = issueNode(issue);
+	return node === void 0 ? void 0 : granularityOf(node.nodeKind);
+}
+/**
+* Resolves an issue's storage `entityKind` on demand, from the issue's
+* node's `nodeKind` via the target-provided `entityKindOf` map — the sibling
+* of {@link classifyDiffSubjectGranularity}, called the same way by the same
+* consumers (via
+* {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}).
+* `undefined` for an issue with no node, or for a node kind with no storage
+* entity of its own.
+*/
+function classifyDiffEntityKind(issue, entityKindOf) {
+	const node = issueNode(issue);
+	return node === void 0 ? void 0 : entityKindOf(node.nodeKind);
+}
+/**
+* Re-keys the legacy `classifySqlVerifierIssueKind` category mapping on the
+* issue's {@link DiffSubjectGranularity} (resolved via `granularityOf`) + the
+* issue reason. The vocabulary maps one-to-one: an undeclared live entity or
+* namespace is `extraTopLevelObject`, an undeclared live field
+* `extraNestedElement`, undeclared auxiliaries (constraints, indexes,
+* defaults) and structural leaves (policies) `extraAuxiliary`; a value-set
+* drift on a check node is `valueDrift`; every other paired divergence is
+* `declaredIncompatible`; anything the database lacks is `declaredMissing`.
+* `granularityOf` is the target's classifier, so target and extension node
+* kinds classify without the family importing them.
+*/
+function classifySqlDiffIssue(issue, granularityOf) {
+	if (issue.reason === "not-found") return "declaredMissing";
+	if (issue.reason === "not-expected") {
+		const granularity = classifyDiffSubjectGranularity(issue, granularityOf);
+		if (granularity === "entity" || granularity === "namespace") return "extraTopLevelObject";
+		if (granularity === "field") return "extraNestedElement";
+		return "extraAuxiliary";
+	}
+	if (issueNode(issue)?.nodeKind === RelationalSchemaNodeKind.check) return "valueDrift";
+	return "declaredIncompatible";
+}
+/**
+* Whether a `not-expected` issue is a strict-mode-only finding. The legacy
+* walk detected every relational extra (namespaces, entities, fields, and
+* their auxiliaries) only under `--strict`; the structural diff (roots, RLS
+* policies, roles) was never strict-gated — its extras fail in both modes.
+* Keyed on the issue's granularity, resolved via `granularityOf`.
+*/
+function isStrictOnlyExtra(issue, granularityOf) {
+	const granularity = classifyDiffSubjectGranularity(issue, granularityOf);
+	return granularity === "namespace" || granularity === "entity" || granularity === "field" || granularity === "auxiliary";
+}
+/**
+* Applies the two consumer filters to a diff issue list: strict gating
+* (relational `not-expected` findings drop in lenient mode) and
+* control-policy disposition (each surviving issue grades against its
+* subject table's effective policy; suppressed issues drop, `observed`
+* subjects warn). The verify verdict is `failures.length === 0`.
+*/
+function computeSqlDiffVerdict(input) {
+	const failures = [];
+	const warnings = [];
+	for (const issue of input.issues) {
+		if (!input.strict && issue.reason === "not-expected" && isStrictOnlyExtra(issue, input.granularityOf)) continue;
+		const disposition = dispositionForCategory(effectiveControlPolicy(input.resolveControlPolicy(issue), input.defaultControlPolicy), classifySqlDiffIssue(issue, input.granularityOf));
+		if (disposition === "suppress") continue;
+		if (disposition === "warn") {
+			warnings.push(issue);
+			continue;
+		}
+		failures.push(issue);
+	}
+	return {
+		failures,
+		warnings
+	};
+}
+function computeStorageTypeVerdict(input) {
+	const failures = [];
+	const warnings = [];
+	const policy = effectiveControlPolicy(void 0, input.contract.defaultControlPolicy);
+	for (const pair of input.namespacePairs) {
+		if (pair.actual === void 0) continue;
+		for (const [typeName, typeInstance] of Object.entries(input.contract.storage.types ?? {})) {
+			if (!isStorageTypeInstance(typeInstance)) continue;
+			const hook = input.codecHooks.get(typeInstance.codecId);
+			if (!hook?.verifyType) continue;
+			const typeIssues = hook.verifyType({
+				typeName,
+				typeInstance,
+				schema: pair.actual
+			});
+			for (const issue of typeIssues) {
+				const disposition = verifierDisposition(policy, issue);
+				if (disposition === "suppress") continue;
+				if (disposition === "warn") {
+					warnings.push(issue);
+					continue;
+				}
+				failures.push(issue);
+			}
+		}
+	}
+	return {
+		failures,
+		warnings
+	};
+}
+/**
+* THE SQL schema verify: runs the target's full-tree node diff, grades it
+* through the family's post-diff filters (strict gating + control-policy
+* disposition) plus the codec `verifyType` hook findings, and wraps the
+* verdict in the issue-based result envelope. `ok` holds exactly when both
+* issue lists are empty — the lists carry the verdict's failures.
+*/
+function verifySqlSchemaByDiff(input) {
+	const startTime = Date.now();
+	const verdictDiff = input.diffSchema({
+		contract: input.contract,
+		schema: input.schema,
+		frameworkComponents: input.frameworkComponents
+	});
+	const diffVerdict = computeSqlDiffVerdict({
+		issues: verdictDiff.issues,
+		resolveControlPolicy: verdictDiff.resolveControlPolicy,
+		strict: input.strict,
+		defaultControlPolicy: input.contract.defaultControlPolicy,
+		granularityOf: input.granularityOf
+	});
+	const storageTypeVerdict = computeStorageTypeVerdict({
+		contract: input.contract,
+		namespacePairs: verdictDiff.namespacePairs,
+		codecHooks: extractCodecControlHooks(input.frameworkComponents)
+	});
+	const failCount = diffVerdict.failures.length + storageTypeVerdict.failures.length;
+	const ok = failCount === 0;
+	const profileHash = "profileHash" in input.contract && typeof input.contract.profileHash === "string" ? input.contract.profileHash : void 0;
+	return {
+		ok,
+		...ok ? {} : { code: "PN-SCHEMA-0001" },
+		summary: ok ? "Database schema satisfies contract" : `Database schema does not satisfy contract (${failCount} failure${failCount === 1 ? "" : "s"})`,
+		contract: {
+			storageHash: input.contract.storage.storageHash,
+			...ifDefined("profileHash", profileHash)
+		},
+		target: {
+			expected: input.contract.target,
+			actual: input.contract.target
+		},
+		schema: {
+			issues: [...diffVerdict.failures, ...storageTypeVerdict.failures],
+			warnings: { issues: [...diffVerdict.warnings, ...storageTypeVerdict.warnings] }
+		},
+		meta: { strict: input.strict },
+		timings: { total: Date.now() - startTime }
+	};
+}
+//#endregion
+export { computeStorageTypeVerdict as a, computeSqlDiffVerdict as i, classifyDiffSubjectGranularity as n, verifySqlSchemaByDiff as o, classifySqlDiffIssue as r, extractCodecControlHooks as s, classifyDiffEntityKind as t };
+
+//# sourceMappingURL=schema-verify-W3r631Jh.mjs.map

package/dist/schema-verify-W3r631Jh.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-verify-W3r631Jh.mjs","names":["d"],"sources":["../src/core/assembly.ts","../src/core/diff/verifier-disposition.ts","../src/core/diff/schema-verify.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 { ControlPolicy } from '@prisma-next/contract/types';\nimport type {\n  SchemaDiffIssue,\n  VerifierIssueCategory,\n  VerifierOutcome,\n} from '@prisma-next/framework-components/control';\nimport { dispositionForCategory } from '@prisma-next/framework-components/control';\n\n/**\n * Classifies a codec `verifyType` hook finding into the target-neutral\n * categories the framework grades. A storage type is a named type instance\n * (e.g. a native enum); the only shape divergence it can carry is a change\n * to its value set, so a paired mismatch always classifies as `valueDrift`.\n */\nexport function classifyStorageTypeDiffIssue(issue: SchemaDiffIssue): VerifierIssueCategory {\n  if (issue.reason === 'not-found') {\n    return 'declaredMissing';\n  }\n  if (issue.reason === 'not-expected') {\n    return 'extraAuxiliary';\n  }\n  return 'valueDrift';\n}\n\nexport function verifierDisposition(\n  controlPolicy: ControlPolicy,\n  issue: SchemaDiffIssue,\n): VerifierOutcome {\n  return dispositionForCategory(controlPolicy, classifyStorageTypeDiffIssue(issue));\n}\n","/**\n * The differ-based SQL schema verify: post-diff filters and verdict.\n *\n * The generic node differ (`diffSchemas`) reports every node-level\n * difference between the derived expected tree and the introspected actual\n * tree. This module is the consumer side the spec assigns to the SQL\n * family: strict-mode extras gating and control-policy disposition are\n * reason/kind-keyed filters applied AFTER the diff — never inside it — and\n * the verify verdict derives from the filtered issue list.\n *\n * `verifySqlSchemaByDiff` wraps the verdict in the issue-based result\n * envelope — this is THE SQL schema verify (the legacy relational walk and\n * its verification tree are retired).\n */\n\nimport type { Contract, ControlPolicy } from '@prisma-next/contract/types';\nimport { effectiveControlPolicy } from '@prisma-next/contract/types';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  DiffSubjectGranularity,\n  SchemaDiffIssue,\n  VerifierIssueCategory,\n  VerifierOutcome,\n  VerifyDatabaseSchemaResult,\n} from '@prisma-next/framework-components/control';\nimport { dispositionForCategory } from '@prisma-next/framework-components/control';\nimport { isStorageTypeInstance, type SqlStorage } from '@prisma-next/sql-contract/types';\nimport { RelationalSchemaNodeKind, type SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { extractCodecControlHooks } from '../assembly';\nimport type { SqlSchemaDiffFn } from '../migrations/schema-differ';\nimport type { CodecControlHooks } from '../migrations/types';\nimport { verifierDisposition } from './verifier-disposition';\n\n// ============================================================================\n// Subject-granularity classification — nodeKind → framework-neutral granularity\n// ============================================================================\n\nfunction issueNode(issue: SchemaDiffIssue): SqlSchemaIRNode | undefined {\n  const node = issue.expected ?? issue.actual;\n  if (node === undefined) return undefined;\n  return blindCast<\n    SqlSchemaIRNode,\n    'every node in a SQL schema diff tree is a SqlSchemaIRNode; nodeKind is its identity'\n  >(node);\n}\n\n/**\n * Resolves an issue's framework-neutral {@link DiffSubjectGranularity} on\n * demand, from the issue's node's `nodeKind` via the target-provided\n * `granularityOf` map. The node carries only its `nodeKind` identity, never a\n * classification, and nothing is stamped onto the issue — every consumer\n * (the family verdict below, the framework aggregate's unclaimed-elements\n * sweep via {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable})\n * calls this the same way, resolved by the family/target that owns the node\n * vocabulary. `undefined` for an issue with no node.\n */\nexport function classifyDiffSubjectGranularity(\n  issue: SchemaDiffIssue,\n  granularityOf: (nodeKind: string) => DiffSubjectGranularity,\n): DiffSubjectGranularity | undefined {\n  const node = issueNode(issue);\n  return node === undefined ? undefined : granularityOf(node.nodeKind);\n}\n\n/**\n * Resolves an issue's storage `entityKind` on demand, from the issue's\n * node's `nodeKind` via the target-provided `entityKindOf` map — the sibling\n * of {@link classifyDiffSubjectGranularity}, called the same way by the same\n * consumers (via\n * {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}).\n * `undefined` for an issue with no node, or for a node kind with no storage\n * entity of its own.\n */\nexport function classifyDiffEntityKind(\n  issue: SchemaDiffIssue,\n  entityKindOf: (nodeKind: string) => string | undefined,\n): string | undefined {\n  const node = issueNode(issue);\n  return node === undefined ? undefined : entityKindOf(node.nodeKind);\n}\n\n// ============================================================================\n// Issue classification — subject granularity + reason → target-neutral category\n// ============================================================================\n\n/**\n * Re-keys the legacy `classifySqlVerifierIssueKind` category mapping on the\n * issue's {@link DiffSubjectGranularity} (resolved via `granularityOf`) + the\n * issue reason. The vocabulary maps one-to-one: an undeclared live entity or\n * namespace is `extraTopLevelObject`, an undeclared live field\n * `extraNestedElement`, undeclared auxiliaries (constraints, indexes,\n * defaults) and structural leaves (policies) `extraAuxiliary`; a value-set\n * drift on a check node is `valueDrift`; every other paired divergence is\n * `declaredIncompatible`; anything the database lacks is `declaredMissing`.\n * `granularityOf` is the target's classifier, so target and extension node\n * kinds classify without the family importing them.\n */\nexport function classifySqlDiffIssue(\n  issue: SchemaDiffIssue,\n  granularityOf: (nodeKind: string) => DiffSubjectGranularity,\n): VerifierIssueCategory {\n  if (issue.reason === 'not-found') {\n    return 'declaredMissing';\n  }\n  if (issue.reason === 'not-expected') {\n    const granularity = classifyDiffSubjectGranularity(issue, granularityOf);\n    if (granularity === 'entity' || granularity === 'namespace') {\n      return 'extraTopLevelObject';\n    }\n    if (granularity === 'field') {\n      return 'extraNestedElement';\n    }\n    return 'extraAuxiliary';\n  }\n  if (issueNode(issue)?.nodeKind === RelationalSchemaNodeKind.check) {\n    return 'valueDrift';\n  }\n  return 'declaredIncompatible';\n}\n\n/**\n * Whether a `not-expected` issue is a strict-mode-only finding. The legacy\n * walk detected every relational extra (namespaces, entities, fields, and\n * their auxiliaries) only under `--strict`; the structural diff (roots, RLS\n * policies, roles) was never strict-gated — its extras fail in both modes.\n * Keyed on the issue's granularity, resolved via `granularityOf`.\n */\nfunction isStrictOnlyExtra(\n  issue: SchemaDiffIssue,\n  granularityOf: (nodeKind: string) => DiffSubjectGranularity,\n): boolean {\n  const granularity = classifyDiffSubjectGranularity(issue, granularityOf);\n  return (\n    granularity === 'namespace' ||\n    granularity === 'entity' ||\n    granularity === 'field' ||\n    granularity === 'auxiliary'\n  );\n}\n\n// ============================================================================\n// The post-diff filter + verdict\n// ============================================================================\n\nexport interface SqlDiffVerdictInput {\n  /** The full, ownership-scoped diff issue list from the target's differ. */\n  readonly issues: readonly SchemaDiffIssue[];\n  /** Resolves a diff issue's subject table's declared control policy directly from the contract. */\n  readonly resolveControlPolicy: (issue: SchemaDiffIssue) => ControlPolicy | undefined;\n  readonly strict: boolean;\n  readonly defaultControlPolicy: ControlPolicy | undefined;\n  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */\n  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;\n}\n\nexport interface SqlDiffVerdict {\n  readonly failures: readonly SchemaDiffIssue[];\n  readonly warnings: readonly SchemaDiffIssue[];\n}\n\n/**\n * Applies the two consumer filters to a diff issue list: strict gating\n * (relational `not-expected` findings drop in lenient mode) and\n * control-policy disposition (each surviving issue grades against its\n * subject table's effective policy; suppressed issues drop, `observed`\n * subjects warn). The verify verdict is `failures.length === 0`.\n */\nexport function computeSqlDiffVerdict(input: SqlDiffVerdictInput): SqlDiffVerdict {\n  const failures: SchemaDiffIssue[] = [];\n  const warnings: SchemaDiffIssue[] = [];\n  for (const issue of input.issues) {\n    if (\n      !input.strict &&\n      issue.reason === 'not-expected' &&\n      isStrictOnlyExtra(issue, input.granularityOf)\n    ) {\n      continue;\n    }\n    const tablePolicy = input.resolveControlPolicy(issue);\n    const policy = effectiveControlPolicy(tablePolicy, input.defaultControlPolicy);\n    const disposition: VerifierOutcome = dispositionForCategory(\n      policy,\n      classifySqlDiffIssue(issue, input.granularityOf),\n    );\n    if (disposition === 'suppress') continue;\n    if (disposition === 'warn') {\n      warnings.push(issue);\n      continue;\n    }\n    failures.push(issue);\n  }\n  return { failures, warnings };\n}\n\n// ============================================================================\n// Storage-types check — the codec verifyType hook path\n// ============================================================================\n\nexport interface StorageTypeVerdictInput {\n  readonly contract: Contract<SqlStorage>;\n  /**\n   * Expected/actual namespace-node pairs the target's differ input produced:\n   * for a namespaced tree, one entry per expected namespace with a\n   * non-empty table set, paired by DDL schema name (absent actual side for\n   * a schema the database lacks); a flat tree is the sole pair.\n   */\n  readonly namespacePairs: ReadonlyArray<{\n    readonly actual: SqlSchemaIRNode | undefined;\n  }>;\n  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;\n}\n\n/**\n * Runs the codec `verifyType` hooks the way the legacy walk did: once per\n * contract namespace with tables, against that namespace's paired actual\n * node (the hook reads namespace-scoped state such as `enums` off it).\n * Issue dispositions grade against the contract default policy, matching\n * the legacy `pushTypeNode` semantics.\n */\nexport interface StorageTypeVerdict {\n  readonly failures: readonly SchemaDiffIssue[];\n  readonly warnings: readonly SchemaDiffIssue[];\n}\n\nexport function computeStorageTypeVerdict(input: StorageTypeVerdictInput): StorageTypeVerdict {\n  const failures: SchemaDiffIssue[] = [];\n  const warnings: SchemaDiffIssue[] = [];\n  const policy = effectiveControlPolicy(undefined, input.contract.defaultControlPolicy);\n  for (const pair of input.namespacePairs) {\n    if (pair.actual === undefined) continue;\n    for (const [typeName, typeInstance] of Object.entries(input.contract.storage.types ?? {})) {\n      if (!isStorageTypeInstance(typeInstance)) continue;\n      const hook = input.codecHooks.get(typeInstance.codecId);\n      if (!hook?.verifyType) continue;\n      const typeIssues = hook.verifyType({ typeName, typeInstance, schema: pair.actual });\n      for (const issue of typeIssues) {\n        const disposition = verifierDisposition(policy, issue);\n        if (disposition === 'suppress') continue;\n        if (disposition === 'warn') {\n          warnings.push(issue);\n          continue;\n        }\n        failures.push(issue);\n      }\n    }\n  }\n  return { failures, warnings };\n}\n\n// ============================================================================\n// The issue-based verify envelope\n// ============================================================================\n\nexport interface VerifySqlSchemaByDiffInput {\n  readonly contract: Contract<SqlStorage>;\n  readonly schema: SqlSchemaIRNode;\n  readonly strict: boolean;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n  /** The target's full-tree node diff (`diffSchema` descriptor hook). */\n  readonly diffSchema: SqlSchemaDiffFn;\n  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */\n  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;\n}\n\n/**\n * THE SQL schema verify: runs the target's full-tree node diff, grades it\n * through the family's post-diff filters (strict gating + control-policy\n * disposition) plus the codec `verifyType` hook findings, and wraps the\n * verdict in the issue-based result envelope. `ok` holds exactly when both\n * issue lists are empty — the lists carry the verdict's failures.\n */\nexport function verifySqlSchemaByDiff(\n  input: VerifySqlSchemaByDiffInput,\n): VerifyDatabaseSchemaResult {\n  const startTime = Date.now();\n  const verdictDiff = input.diffSchema({\n    contract: input.contract,\n    schema: input.schema,\n    frameworkComponents: input.frameworkComponents,\n  });\n  const diffVerdict = computeSqlDiffVerdict({\n    issues: verdictDiff.issues,\n    resolveControlPolicy: verdictDiff.resolveControlPolicy,\n    strict: input.strict,\n    defaultControlPolicy: input.contract.defaultControlPolicy,\n    granularityOf: input.granularityOf,\n  });\n  const storageTypeVerdict = computeStorageTypeVerdict({\n    contract: input.contract,\n    namespacePairs: verdictDiff.namespacePairs,\n    codecHooks: extractCodecControlHooks(input.frameworkComponents),\n  });\n  const failCount = diffVerdict.failures.length + storageTypeVerdict.failures.length;\n  const ok = failCount === 0;\n  const profileHash =\n    'profileHash' in input.contract && typeof input.contract.profileHash === 'string'\n      ? input.contract.profileHash\n      : undefined;\n  return {\n    ok,\n    ...(ok ? {} : { code: 'PN-SCHEMA-0001' }),\n    summary: ok\n      ? 'Database schema satisfies contract'\n      : `Database schema does not satisfy contract (${failCount} failure${failCount === 1 ? '' : 's'})`,\n    contract: {\n      storageHash: input.contract.storage.storageHash,\n      ...ifDefined('profileHash', profileHash),\n    },\n    target: {\n      expected: input.contract.target,\n      actual: input.contract.target,\n    },\n    schema: {\n      issues: [...diffVerdict.failures, ...storageTypeVerdict.failures],\n      warnings: {\n        issues: [...diffVerdict.warnings, ...storageTypeVerdict.warnings],\n      },\n    },\n    meta: { strict: input.strict },\n    timings: { total: Date.now() - startTime },\n  };\n}\n"],"mappings":"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"}

package/dist/{sql-contract-serializer-BR2vC7Z-.mjs → sql-contract-serializer-C75cfMSS.mjs}

@@ -1,11 +1,11 @@
 import { blindCast } from "@prisma-next/utils/casts";
+import { hydrateNamespaceEntities } from "@prisma-next/framework-components/ir";
 import { sqlContractCanonicalizationHooks } from "@prisma-next/sql-contract/canonicalization-hooks";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { NamespaceBase, UNBOUND_NAMESPACE_ID, hydrateNamespaceEntities } from "@prisma-next/framework-components/ir";
+import { SqlStorage, isMaterializedSqlNamespace } from "@prisma-next/sql-contract/types";
 import { ContractValidationError } from "@prisma-next/contract/contract-validation-error";
-import { isPlainRecord } from "@prisma-next/contract/is-plain-record";
+import { isPlainRecord as isPlainRecord$1 } from "@prisma-next/contract/is-plain-record";
 import { composeSqlEntityKinds } from "@prisma-next/sql-contract/entity-kinds";
-import { SqlStorage, SqlUnboundNamespace, buildSqlNamespace } from "@prisma-next/sql-contract/types";
 import { createSqlContractSchema, validateSqlContractFully } from "@prisma-next/sql-contract/validators";
 import { type } from "arktype";
 //#region src/core/ir/sql-contract-serializer-base.ts
@@ -65,39 +65,34 @@ var SqlContractSerializerBase = class {
 		const hydratedTypes = types !== void 0 ? Object.fromEntries(Object.entries(types).map(([name, entry]) => [name, this.hydrateStorageTypeEntry(entry)])) : void 0;
 		const rawNamespaces = validated.storage.namespaces;
 		if (rawNamespaces === void 0) throw new ContractValidationError("Contract storage.namespaces is required after structural validation", "structural");
-		const hydratedNamespaces = this.hydrateSqlNamespaceMap(rawNamespaces);
-		const withInjectedUnbound = this.defaultNamespaceId === UNBOUND_NAMESPACE_ID ? {
-			...hydratedNamespaces,
-			[UNBOUND_NAMESPACE_ID]: hydratedNamespaces[UNBOUND_NAMESPACE_ID] ?? SqlUnboundNamespace.instance
-		} : hydratedNamespaces;
+		const hydratedNamespaces = this.hydrateSqlNamespaceMap(blindCast(rawNamespaces));
 		return {
 			...validated,
 			storage: new SqlStorage({
 				storageHash: validated.storage.storageHash,
 				...ifDefined("types", hydratedTypes),
-				namespaces: blindCast(withInjectedUnbound)
+				namespaces: blindCast(hydratedNamespaces)
 			})
 		};
 	}
 	hydrateSqlNamespaceMap(namespaces) {
 		return Object.fromEntries(Object.entries(namespaces).map(([nsId, namespaceEntryRaw]) => {
 			const namespaceHydrated = this.hydrateSqlNamespaceEntry(nsId, namespaceEntryRaw);
-			return [nsId, namespaceHydrated instanceof NamespaceBase ? namespaceHydrated : buildSqlNamespace(blindCast(namespaceHydrated))];
+			if (!isMaterializedSqlNamespace(namespaceHydrated)) throw new Error(`Target serializer bug: hydrateSqlNamespaceEntry for namespace "${nsId}" returned a non-NamespaceBase value. Override hydrateSqlNamespaceEntry to produce a target namespace concretion.`);
+			return [nsId, namespaceHydrated];
 		}));
 	}
 	hydrateSqlNamespaceEntry(nsId, raw) {
-		if (raw instanceof NamespaceBase) return raw;
-		const rawRecord = isPlainRecord(raw) ? raw : {};
-		const id = typeof rawRecord["id"] === "string" ? rawRecord["id"] : nsId;
+		const id = typeof raw["id"] === "string" ? raw["id"] : nsId;
 		const parsed = NamespaceRawSchema({
-			...rawRecord,
+			...raw,
 			id
 		});
 		if (parsed instanceof type.errors) throw new ContractValidationError(`Namespace hydration failed: ${parsed.map((p) => p.message).join("; ")}`, "structural");
 		const entriesRaw = parsed.entries;
-		const rawEntriesMap = isPlainRecord(entriesRaw) ? entriesRaw : {};
+		const rawEntriesMap = isPlainRecord$1(entriesRaw) ? entriesRaw : {};
 		const entriesInput = {};
-		for (const [key, innerMap] of Object.entries(rawEntriesMap)) entriesInput[key] = isPlainRecord(innerMap) ? innerMap : Object.freeze({});
+		for (const [key, innerMap] of Object.entries(rawEntriesMap)) entriesInput[key] = isPlainRecord$1(innerMap) ? innerMap : Object.freeze({});
 		const entriesOutput = hydrateNamespaceEntities(entriesInput, this.entryKinds, "fail", id);
 		if (!Object.hasOwn(entriesOutput, "table")) entriesOutput["table"] = {};
 		return blindCast({
@@ -116,6 +111,35 @@ var SqlContractSerializerBase = class {
 	constructTargetContract(hydrated) {
 		return hydrated;
 	}
+	/**
+	* Serializes a namespace's `entries` dict by walking every enumerable
+	* kind — no kind is named here, mirroring the generic hydrate walk in
+	* `hydrateSqlNamespaceEntry` above. `table` is the SQL family's one
+	* universal base kind (every namespace carries it), so it is always
+	* emitted, even when empty; every other kind — target- or
+	* pack-contributed — is emitted only when it holds at least one entry.
+	* A kind carried non-enumerable on `entries` is excluded here for free,
+	* since `Object.entries` honors enumerability.
+	*/
+	serializeNamespaceEntries(entries) {
+		const out = { table: this.serializeEntries(entries["table"] ?? {}) };
+		for (const [kind, record] of Object.entries(entries)) {
+			if (kind === "table" || record == null || Object.keys(record).length === 0) continue;
+			out[kind] = this.serializeEntries(record);
+		}
+		return out;
+	}
+	serializeEntries(entries) {
+		const out = {};
+		for (const [name, entry] of Object.entries(entries)) out[name] = this.serializeJsonObject(entry);
+		return out;
+	}
+	serializeJsonObject(value) {
+		return blindCast(this.serializeJsonValue(value));
+	}
+	serializeJsonValue(value) {
+		return blindCast(JSON.parse(JSON.stringify(value)));
+	}
 };
 //#endregion
 //#region src/core/ir/sql-contract-serializer.ts
@@ -127,16 +151,18 @@ var SqlContractSerializerBase = class {
 * codec-typed envelope wire a target-specific subclass with a populated
 * registry (see Postgres). Family-level call sites instantiate this
 * default directly when no target serializer is supplied.
+*
+* Because this serializer has no target concretion, deserialization of
+* contracts that include namespace entries from JSON will throw unless
+* the caller provides pre-hydrated `NamespaceBase` instances. Production
+* paths always supply a target-specific serializer.
 */
 var SqlContractSerializer = class extends SqlContractSerializerBase {
 	constructor() {
 		super(/* @__PURE__ */ new Map());
 	}
-	get defaultNamespaceId() {
-		return UNBOUND_NAMESPACE_ID;
-	}
 };
 //#endregion
 export { SqlContractSerializerBase as n, SqlContractSerializer as t };
 
-//# sourceMappingURL=sql-contract-serializer-BR2vC7Z-.mjs.map
+//# sourceMappingURL=sql-contract-serializer-C75cfMSS.mjs.map

package/dist/sql-contract-serializer-C75cfMSS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-contract-serializer-C75cfMSS.mjs","names":["isPlainRecord"],"sources":["../src/core/ir/sql-contract-serializer-base.ts","../src/core/ir/sql-contract-serializer.ts"],"sourcesContent":["import { ContractValidationError } from '@prisma-next/contract/contract-validation-error';\nimport { isPlainRecord } from '@prisma-next/contract/is-plain-record';\nimport type { Contract } from '@prisma-next/contract/types';\nimport type { ContractSerializer } from '@prisma-next/framework-components/control';\nimport {\n  type AnyEntityKindDescriptor,\n  hydrateNamespaceEntities,\n  type Namespace,\n} from '@prisma-next/framework-components/ir';\nimport { sqlContractCanonicalizationHooks } from '@prisma-next/sql-contract/canonicalization-hooks';\nimport { composeSqlEntityKinds } from '@prisma-next/sql-contract/entity-kinds';\nimport {\n  isMaterializedSqlNamespace,\n  type SqlNamespaceInput,\n  SqlStorage,\n  type SqlStorageInput,\n  type SqlStorageTypeEntry,\n} from '@prisma-next/sql-contract/types';\nimport {\n  createSqlContractSchema,\n  validateSqlContractFully,\n} from '@prisma-next/sql-contract/validators';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { JsonObject, JsonValue } from '@prisma-next/utils/json';\nimport { type Type, type } from 'arktype';\n\nconst NamespaceRawSchema = type({\n  id: 'string',\n  'kind?': 'string',\n  entries: type({\n    '+': 'ignore',\n  }),\n});\n\nexport type SqlEntityHydrationFactory = (entry: unknown) => unknown;\n\n/**\n * SQL family `ContractSerializer` abstract base. Carries the SQL-shared\n * deserialization pipeline:\n *\n * 1. `parseSqlContractStructure` validates the on-disk JSON envelope\n *    against the SQL contract arktype schema (`validateSqlContractFully`)\n *    and returns the validated flat-data shape.\n * 2. `hydrateSqlStorage` walks the validated `storage` subtree and\n *    constructs the family-shared SQL Contract IR class hierarchy\n *    (`SqlStorage` -> `StorageTable` -> `StorageColumn` / `PrimaryKey`\n *    / …). The rest of the contract envelope is JSON-clean primitive\n *    data and passes through unchanged.\n * 3. `constructTargetContract` is the target-specific extension hook;\n *    defaults to identity. Targets that need to attach target-only\n *    fields (e.g. target-specific derived storage fields) override it.\n *\n * Default `serializeContract` is identity over the contract — concrete\n * SQL targets ship JSON-clean class instances, so the contract value\n * can be stringified directly. The non-enumerable family-level `kind`\n * discriminator on `SqlNode` instances stays out of the persisted\n * envelope automatically. Targets that need to canonicalize on the way\n * out (key ordering, dropping computed-only fields) override\n * `serializeContract` directly.\n */\nexport abstract class SqlContractSerializerBase<TContract extends Contract<SqlStorage>>\n  implements ContractSerializer<TContract>\n{\n  private readonly contractSchema: Type<unknown> | undefined;\n  private readonly entryKinds: ReadonlyMap<string, AnyEntityKindDescriptor>;\n\n  constructor(\n    protected readonly entityHydrationRegistry: ReadonlyMap<\n      string,\n      SqlEntityHydrationFactory\n    > = new Map(),\n    packEntityKinds: readonly AnyEntityKindDescriptor[] = [],\n  ) {\n    this.entryKinds = composeSqlEntityKinds(packEntityKinds);\n    this.contractSchema =\n      packEntityKinds.length > 0 ? createSqlContractSchema(this.entryKinds) : undefined;\n  }\n\n  deserializeContract<T extends TContract = TContract>(json: unknown): T {\n    const validated = this.parseSqlContractStructure(json);\n    const hydrated = this.hydrateSqlStorage(validated);\n    return this.constructTargetContract(hydrated) as T;\n  }\n\n  serializeContract(contract: TContract): JsonObject {\n    return contract as unknown as JsonObject;\n  }\n\n  shouldPreserveEmpty = sqlContractCanonicalizationHooks.shouldPreserveEmpty;\n\n  sortStorage = sqlContractCanonicalizationHooks.sortStorage;\n\n  protected parseSqlContractStructure(json: unknown): Contract<SqlStorage> {\n    return validateSqlContractFully<Contract<SqlStorage>>(\n      json,\n      this.contractSchema !== undefined ? { contractSchema: this.contractSchema } : undefined,\n    );\n  }\n\n  protected hydrateSqlStorage(validated: Contract<SqlStorage>): Contract<SqlStorage> {\n    const types = validated.storage.types;\n    const hydratedTypes =\n      types !== undefined\n        ? Object.fromEntries(\n            Object.entries(types).map(([name, entry]) => [\n              name,\n              this.hydrateStorageTypeEntry(entry),\n            ]),\n          )\n        : undefined;\n\n    const rawNamespaces = validated.storage.namespaces;\n    if (rawNamespaces === undefined) {\n      throw new ContractValidationError(\n        'Contract storage.namespaces is required after structural validation',\n        'structural',\n      );\n    }\n    const hydratedNamespaces = this.hydrateSqlNamespaceMap(\n      blindCast<\n        Readonly<Record<string, Record<string, unknown>>>,\n        'parseSqlContractStructure validated raw JSON; namespace entries are plain objects, not SqlNamespace instances.'\n      >(rawNamespaces),\n    );\n\n    return {\n      ...validated,\n      storage: new SqlStorage({\n        storageHash: validated.storage.storageHash,\n        ...ifDefined('types', hydratedTypes),\n        namespaces: blindCast<\n          SqlStorageInput['namespaces'],\n          'hydrateSqlNamespaceMap builds each namespace through the target serializer override, so every value is a SqlNamespace; the framework return type only promises the base Namespace.'\n        >(hydratedNamespaces),\n      }),\n    };\n  }\n\n  protected hydrateSqlNamespaceMap(\n    namespaces: Readonly<Record<string, Record<string, unknown>>>,\n  ): Readonly<Record<string, Namespace>> {\n    return Object.fromEntries(\n      Object.entries(namespaces).map(([nsId, namespaceEntryRaw]) => {\n        const namespaceHydrated = this.hydrateSqlNamespaceEntry(nsId, namespaceEntryRaw);\n        if (!isMaterializedSqlNamespace(namespaceHydrated)) {\n          throw new Error(\n            `Target serializer bug: hydrateSqlNamespaceEntry for namespace \"${nsId}\" returned a non-NamespaceBase value. Override hydrateSqlNamespaceEntry to produce a target namespace concretion.`,\n          );\n        }\n        return [nsId, namespaceHydrated];\n      }),\n    );\n  }\n\n  protected hydrateSqlNamespaceEntry(\n    nsId: string,\n    raw: Record<string, unknown>,\n  ): Namespace | SqlNamespaceInput {\n    const id = typeof raw['id'] === 'string' ? raw['id'] : nsId;\n    const parsed = NamespaceRawSchema({ ...raw, id });\n    if (parsed instanceof type.errors) {\n      const messages = parsed.map((p: { message: string }) => p.message).join('; ');\n      throw new ContractValidationError(`Namespace hydration failed: ${messages}`, 'structural');\n    }\n    const entriesRaw = parsed.entries;\n    const rawEntriesMap = isPlainRecord(entriesRaw) ? entriesRaw : {};\n\n    const entriesInput: Record<string, Readonly<Record<string, unknown>>> = {};\n    for (const [key, innerMap] of Object.entries(rawEntriesMap)) {\n      entriesInput[key] = isPlainRecord(innerMap) ? innerMap : Object.freeze({});\n    }\n\n    const entriesOutput = hydrateNamespaceEntities(entriesInput, this.entryKinds, 'fail', id);\n\n    // Always ensure a 'table' key is present (may be empty).\n    if (!Object.hasOwn(entriesOutput, 'table')) {\n      entriesOutput['table'] = {};\n    }\n\n    return blindCast<\n      SqlNamespaceInput,\n      'entriesOutput holds the hydrated SQL entity-kind maps (table always present); this wraps them as the SqlNamespaceInput the target createNamespace consumes.'\n    >({\n      id,\n      entries: entriesOutput,\n    });\n  }\n\n  protected hydrateStorageTypeEntry(entry: SqlStorageTypeEntry): SqlStorageTypeEntry {\n    if (typeof entry !== 'object' || entry === null) {\n      return entry;\n    }\n    const kind = (entry as { kind?: unknown }).kind;\n    if (typeof kind !== 'string') {\n      return entry;\n    }\n    const factory = this.entityHydrationRegistry.get(kind);\n    if (factory === undefined) {\n      return entry;\n    }\n    return blindCast<\n      SqlStorageTypeEntry,\n      'entity registry factory returns SqlStorageTypeEntry for storage.types entries'\n    >(factory(entry));\n  }\n\n  protected constructTargetContract(hydrated: Contract<SqlStorage>): TContract {\n    return hydrated as TContract;\n  }\n\n  /**\n   * Serializes a namespace's `entries` dict by walking every enumerable\n   * kind — no kind is named here, mirroring the generic hydrate walk in\n   * `hydrateSqlNamespaceEntry` above. `table` is the SQL family's one\n   * universal base kind (every namespace carries it), so it is always\n   * emitted, even when empty; every other kind — target- or\n   * pack-contributed — is emitted only when it holds at least one entry.\n   * A kind carried non-enumerable on `entries` is excluded here for free,\n   * since `Object.entries` honors enumerability.\n   */\n  protected serializeNamespaceEntries(\n    entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>,\n  ): Record<string, Record<string, JsonObject>> {\n    const out: Record<string, Record<string, JsonObject>> = {\n      table: this.serializeEntries(entries['table'] ?? {}),\n    };\n    for (const [kind, record] of Object.entries(entries)) {\n      if (kind === 'table' || record == null || Object.keys(record).length === 0) {\n        continue;\n      }\n      out[kind] = this.serializeEntries(record);\n    }\n    return out;\n  }\n\n  private serializeEntries(entries: Readonly<Record<string, unknown>>): Record<string, JsonObject> {\n    const out: Record<string, JsonObject> = {};\n    for (const [name, entry] of Object.entries(entries)) {\n      out[name] = this.serializeJsonObject(entry);\n    }\n    return out;\n  }\n\n  protected serializeJsonObject(value: unknown): JsonObject {\n    return blindCast<\n      JsonObject,\n      'serializeJsonValue round-trips an IR node through JSON, yielding a JsonObject'\n    >(this.serializeJsonValue(value));\n  }\n\n  private serializeJsonValue(value: unknown): JsonValue {\n    return blindCast<JsonValue, 'JSON.parse(JSON.stringify(x)) yields a JsonValue'>(\n      JSON.parse(JSON.stringify(value)),\n    );\n  }\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { SqlContractSerializerBase } from './sql-contract-serializer-base';\n\n/**\n * Default SQL family `ContractSerializer` concretion. Inherits the\n * full SQL-shared deserialization pipeline (structural validation +\n * IR-class hydration) without pack-registered `storage.types`\n * hydration factories — targets that emit polymorphic JSON outside the\n * codec-typed envelope wire a target-specific subclass with a populated\n * registry (see Postgres). Family-level call sites instantiate this\n * default directly when no target serializer is supplied.\n *\n * Because this serializer has no target concretion, deserialization of\n * contracts that include namespace entries from JSON will throw unless\n * the caller provides pre-hydrated `NamespaceBase` instances. Production\n * paths always supply a target-specific serializer.\n */\nexport class SqlContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {\n  constructor() {\n    super(new Map());\n  }\n}\n"],"mappings":"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"}