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

package/dist/diff.d.mts

@@ -1,39 +1,150 @@
-import { a as verifySqlSchemaTree, i as verifySqlSchema, n as NativeTypeNormalizer, r as VerifySqlSchemaOptions } from "./sql-schema-diff-6z36dZt6.mjs";
-import { ControlPolicy } from "@prisma-next/contract/types";
-import { SchemaIssue } from "@prisma-next/framework-components/control";
-import { SqlForeignKeyIR, SqlIndexIR, SqlUniqueIR } from "@prisma-next/sql-schema-ir/types";
+import { a as NativeTypeNormalizer, c as isUniqueConstraintSatisfied, o as arraysEqual, s as isIndexSatisfied } from "./control-adapter-BVOj4gXI.mjs";
+import { n as CodecControlHooks } from "./types-BW7pzb2j.mjs";
+import { t as SqlSchemaDiffFn } from "./schema-differ-DnoopSXm.mjs";
+import { DiffSubjectGranularity, SchemaDiffIssue, VerifierIssueCategory, VerifyDatabaseSchemaResult } from "@prisma-next/framework-components/control";
+import { Contract, ControlPolicy } from "@prisma-next/contract/types";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
+import { SqlIndexIR, SqlSchemaIR, SqlSchemaIRNode, SqlUniqueIR } from "@prisma-next/sql-schema-ir/types";
+import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
 
-//#region src/core/diff/verify-helpers.d.ts
+//#region src/core/diff/diff-tree-normalization.d.ts
+interface SemanticSatisfactionInput {
+  readonly expectedUniques: readonly SqlUniqueIR[];
+  readonly expectedIndexes: readonly SqlIndexIR[];
+  readonly actualUniques: readonly SqlUniqueIR[];
+  readonly actualIndexes: readonly SqlIndexIR[];
+}
+interface SemanticSatisfactionResult {
+  readonly actualUniques: readonly SqlUniqueIR[];
+  readonly actualIndexes: readonly SqlIndexIR[];
+}
 /**
- * Compares two arrays of strings for equality (order-sensitive).
+ * Adjusts a table pair's ACTUAL unique/index child lists so the legacy
+ * walk's cross-kind semantic satisfaction materializes as same-kind node
+ * pairs for the differ (the differ pairs strictly by id, so a `unique:`
+ * node can never pair with an `index:` node). Three legacy rules, ported
+ * from `isUniqueConstraintSatisfied` / `isIndexSatisfied` and the
+ * strict-extras loops of the retired relational walk:
+ *
+ * 1. A contract unique satisfied by a live unique INDEX: the actual index
+ *    node is reclassified as a unique node (it pairs with the expected
+ *    unique and stops being a candidate extra).
+ * 2. A contract index (with no type/options demands) satisfied by a live
+ *    unique CONSTRAINT: a same-kind actual index node is synthesized so
+ *    the expected index pairs — the unique constraint itself stays (the
+ *    legacy strict-extras loop still reports it as an undeclared unique).
+ * 3. Live unique indexes are never extras in the legacy walk (its
+ *    strict-extras loop skips `unique: true` rows), so any remaining
+ *    actual unique-index node with no expected index counterpart is
+ *    dropped rather than surfacing as `not-expected`.
  */
-declare function arraysEqual(a: readonly string[], b: readonly string[]): boolean;
+declare function resolveSemanticSatisfaction(input: SemanticSatisfactionInput): SemanticSatisfactionResult;
 /**
- * Checks if a unique constraint requirement is satisfied by the given columns.
- *
- * Semantic satisfaction: a unique constraint requirement can be satisfied by:
- * - A unique constraint with the same columns, OR
- * - A unique index with the same columns
- *
- * @param uniques - The unique constraints in the schema table
- * @param indexes - The indexes in the schema table
- * @param columns - The columns required by the unique constraint
- * @returns true if the requirement is satisfied
+ * Applies {@link resolveSemanticSatisfaction} across a flat table pair set:
+ * every actual table with an expected counterpart gets its unique/index
+ * child lists adjusted; unpaired tables pass through untouched.
  */
-declare function isUniqueConstraintSatisfied(uniques: readonly SqlUniqueIR[], indexes: readonly SqlIndexIR[], columns: readonly string[]): boolean;
+declare function normalizeFlatActualForDiff(expected: SqlSchemaIR, actual: SqlSchemaIR): SqlSchemaIR;
 /**
- * Checks if an index requirement is satisfied by the given columns.
- *
- * Semantic satisfaction: a non-unique index requirement can be satisfied by:
- * - Any index (unique or non-unique) with the same columns, OR
- * - A unique constraint with the same columns (stronger satisfies weaker)
- *
- * @param indexes - The indexes in the schema table
- * @param uniques - The unique constraints in the schema table
- * @param columns - The columns required by the index
- * @returns true if the requirement is satisfied
+ * Neutralizes the FK schema segment on a flat expected tree so its FK diff
+ * nodes pair with introspected FKs on single-schema targets: the family
+ * converter stamps `referencedSchema` with the contract namespace id
+ * verbatim (the unbound sentinel on non-namespaced targets), while a
+ * single-schema introspection stamps none — resolving both sides to the
+ * empty segment makes the ids meet.
+ */
+declare function neutralizeFlatExpectedFkSchemas(expected: SqlSchemaIR): SqlSchemaIR;
+//#endregion
+//#region src/core/diff/schema-verify.d.ts
+/**
+ * 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.
+ */
+declare function classifyDiffSubjectGranularity(issue: SchemaDiffIssue, granularityOf: (nodeKind: string) => DiffSubjectGranularity): DiffSubjectGranularity | undefined;
+/**
+ * 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.
+ */
+declare function classifySqlDiffIssue(issue: SchemaDiffIssue, granularityOf: (nodeKind: string) => DiffSubjectGranularity): VerifierIssueCategory;
+interface SqlDiffVerdictInput {
+  /** The full, ownership-scoped diff issue list from the target's differ. */
+  readonly issues: readonly SchemaDiffIssue[];
+  /** Resolves a diff issue's subject table's declared control policy directly from the contract. */
+  readonly resolveControlPolicy: (issue: SchemaDiffIssue) => ControlPolicy | undefined;
+  readonly strict: boolean;
+  readonly defaultControlPolicy: ControlPolicy | undefined;
+  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */
+  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;
+}
+interface SqlDiffVerdict {
+  readonly failures: readonly SchemaDiffIssue[];
+  readonly warnings: readonly SchemaDiffIssue[];
+}
+/**
+ * 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`.
+ */
+declare function computeSqlDiffVerdict(input: SqlDiffVerdictInput): SqlDiffVerdict;
+interface StorageTypeVerdictInput {
+  readonly contract: Contract<SqlStorage>;
+  /**
+   * Expected/actual namespace-node pairs the target's differ input produced:
+   * for a namespaced tree, one entry per expected namespace with a
+   * non-empty table set, paired by DDL schema name (absent actual side for
+   * a schema the database lacks); a flat tree is the sole pair.
+   */
+  readonly namespacePairs: ReadonlyArray<{
+    readonly actual: SqlSchemaIRNode | undefined;
+  }>;
+  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
+}
+/**
+ * Runs the codec `verifyType` hooks the way the legacy walk did: once per
+ * contract namespace with tables, against that namespace's paired actual
+ * node (the hook reads namespace-scoped state such as
+ * `nativeEnumTypeNames` off it). Issue dispositions grade against the
+ * contract default policy, matching the legacy `pushTypeNode` semantics.
+ */
+interface StorageTypeVerdict {
+  readonly failures: readonly SchemaDiffIssue[];
+  readonly warnings: readonly SchemaDiffIssue[];
+}
+declare function computeStorageTypeVerdict(input: StorageTypeVerdictInput): StorageTypeVerdict;
+interface VerifySqlSchemaByDiffInput {
+  readonly contract: Contract<SqlStorage>;
+  readonly schema: SqlSchemaIRNode;
+  readonly strict: boolean;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  /** The target's full-tree node diff (`diffSchema` descriptor hook). */
+  readonly diffSchema: SqlSchemaDiffFn;
+  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */
+  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;
+}
+/**
+ * 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.
  */
-declare function isIndexSatisfied(indexes: readonly SqlIndexIR[], uniques: readonly SqlUniqueIR[], columns: readonly string[]): boolean;
+declare function verifySqlSchemaByDiff(input: VerifySqlSchemaByDiffInput): VerifyDatabaseSchemaResult;
 //#endregion
-export { type NativeTypeNormalizer, type VerifySqlSchemaOptions, arraysEqual, isIndexSatisfied, isUniqueConstraintSatisfied, verifySqlSchema, verifySqlSchemaTree };
+export { type NativeTypeNormalizer, type SemanticSatisfactionInput, type SemanticSatisfactionResult, type SqlDiffVerdict, type SqlDiffVerdictInput, type StorageTypeVerdict, type StorageTypeVerdictInput, type VerifySqlSchemaByDiffInput, arraysEqual, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, isIndexSatisfied, isUniqueConstraintSatisfied, neutralizeFlatExpectedFkSchemas, normalizeFlatActualForDiff, resolveSemanticSatisfaction, verifySqlSchemaByDiff };
 //# sourceMappingURL=diff.d.mts.map

package/dist/diff.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"diff.d.mts","names":[],"sources":["../src/core/diff/verify-helpers.ts"],"mappings":";;;;;;;;;iBAgEgB,WAAA,CAAY,CAAA,qBAAsB,CAAoB;AA+BtE;;;;;;;;;;AAG4B;AAuB5B;AA1BA,iBAAgB,2BAAA,CACd,OAAA,WAAkB,WAAA,IAClB,OAAA,WAAkB,UAAU,IAC5B,OAAA;;;;;;;;;AA0B0B;;;;iBAHZ,gBAAA,CACd,OAAA,WAAkB,UAAA,IAClB,OAAA,WAAkB,WAAW,IAC7B,OAAA"}
+{"version":3,"file":"diff.d.mts","names":[],"sources":["../src/core/diff/diff-tree-normalization.ts","../src/core/diff/schema-verify.ts"],"mappings":";;;;;;;;;;UAqCiB,yBAAA;EAAA,SACN,eAAA,WAA0B,WAAA;EAAA,SAC1B,eAAA,WAA0B,UAAA;EAAA,SAC1B,aAAA,WAAwB,WAAA;EAAA,SACxB,aAAA,WAAwB,UAAA;AAAA;AAAA,UAGlB,0BAAA;EAAA,SACN,aAAA,WAAwB,WAAA;EAAA,SACxB,aAAA,WAAwB,UAAU;AAAA;;;;;AAAA;AA2B7C;;;;;;;;AAE6B;AAyD7B;;;;;;iBA3DgB,2BAAA,CACd,KAAA,EAAO,yBAAA,GACN,0BAA0B;;;;;;iBAyDb,0BAAA,CACd,QAAA,EAAU,WAAA,EACV,MAAA,EAAQ,WAAA,GACP,WAAA;;AAAW;AAuCd;;;;;;iBAAgB,+BAAA,CAAgC,QAAA,EAAU,WAAA,GAAc,WAAW;;;;;;;;;;AArItC;AAG7C;;iBCcgB,8BAAA,CACd,KAAA,EAAO,eAAA,EACP,aAAA,GAAgB,QAAA,aAAqB,sBAAA,GACpC,sBAAA;;;;;;ADc0B;AAyD7B;;;;;;iBCjCgB,oBAAA,CACd,KAAA,EAAO,eAAA,EACP,aAAA,GAAgB,QAAA,aAAqB,sBAAA,GACpC,qBAAA;AAAA,UA4Cc,mBAAA;EDbL;EAAA,SCeD,MAAA,WAAiB,eAAA;EDdlB;EAAA,SCgBC,oBAAA,GAAuB,KAAA,EAAO,eAAA,KAAoB,aAAA;EAAA,SAClD,MAAA;EAAA,SACA,oBAAA,EAAsB,aAAA;EDjBnB;EAAA,SCmBH,aAAA,GAAgB,QAAA,aAAqB,sBAAA;AAAA;AAAA,UAG/B,cAAA;EAAA,SACN,QAAA,WAAmB,eAAA;EAAA,SACnB,QAAA,WAAmB,eAAe;AAAA;;;ADesC;;;;ACpHnF;iBA+GgB,qBAAA,CAAsB,KAAA,EAAO,mBAAA,GAAsB,cAAc;AAAA,UA+BhE,uBAAA;EAAA,SACN,QAAA,EAAU,QAAA,CAAS,UAAA;EA7IS;;;;;;EAAA,SAoJ5B,cAAA,EAAgB,aAAA;IAAA,SACd,MAAA,EAAQ,eAAA;EAAA;EAAA,SAEV,UAAA,EAAY,WAAA,SAAoB,iBAAA;AAAA;AAtJlB;AAsCzB;;;;;;AAtCyB,UAgKR,kBAAA;EAAA,SACN,QAAA,WAAmB,eAAA;EAAA,SACnB,QAAA,WAAmB,eAAe;AAAA;AAAA,iBAG7B,yBAAA,CAA0B,KAAA,EAAO,uBAAA,GAA0B,kBAAkB;AAAA,UA6B5E,0BAAA;EAAA,SACN,QAAA,EAAU,QAAA,CAAS,UAAA;EAAA,SACnB,MAAA,EAAQ,eAAA;EAAA,SACR,MAAA;EAAA,SACA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;EAjH7B;EAAA,SAmHN,UAAA,EAAY,eAAA;;WAEZ,aAAA,GAAgB,QAAA,aAAqB,sBAAA;AAAA;;;;;;;;iBAUhC,qBAAA,CACd,KAAA,EAAO,0BAAA,GACN,0BAA0B"}