@prisma-next/family-sql 0.1.0-dev.15 → 0.1.0-dev.16

package/dist/exports/chunk-I7QWTBWS.js

@@ -0,0 +1,764 @@
+// src/core/schema-verify/verify-sql-schema.ts
+import { ifDefined } from "@prisma-next/utils/defined";
+
+// src/core/schema-verify/verify-helpers.ts
+function arraysEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function verifyPrimaryKey(contractPK, schemaPK, tableName, issues) {
+  if (!schemaPK) {
+    issues.push({
+      kind: "primary_key_mismatch",
+      table: tableName,
+      expected: contractPK.columns.join(", "),
+      message: `Table "${tableName}" is missing primary key`
+    });
+    return "fail";
+  }
+  if (!arraysEqual(contractPK.columns, schemaPK.columns)) {
+    issues.push({
+      kind: "primary_key_mismatch",
+      table: tableName,
+      expected: contractPK.columns.join(", "),
+      actual: schemaPK.columns.join(", "),
+      message: `Table "${tableName}" has primary key mismatch: expected columns [${contractPK.columns.join(", ")}], got [${schemaPK.columns.join(", ")}]`
+    });
+    return "fail";
+  }
+  if (contractPK.name && schemaPK.name && contractPK.name !== schemaPK.name) {
+    issues.push({
+      kind: "primary_key_mismatch",
+      table: tableName,
+      indexOrConstraint: contractPK.name,
+      expected: contractPK.name,
+      actual: schemaPK.name,
+      message: `Table "${tableName}" has primary key name mismatch: expected "${contractPK.name}", got "${schemaPK.name}"`
+    });
+    return "fail";
+  }
+  return "pass";
+}
+function verifyForeignKeys(contractFKs, schemaFKs, tableName, tablePath, issues, strict) {
+  const nodes = [];
+  for (const contractFK of contractFKs) {
+    const fkPath = `${tablePath}.foreignKeys[${contractFK.columns.join(",")}]`;
+    const matchingFK = schemaFKs.find((fk) => {
+      return arraysEqual(fk.columns, contractFK.columns) && fk.referencedTable === contractFK.references.table && arraysEqual(fk.referencedColumns, contractFK.references.columns);
+    });
+    if (!matchingFK) {
+      issues.push({
+        kind: "foreign_key_mismatch",
+        table: tableName,
+        expected: `${contractFK.columns.join(", ")} -> ${contractFK.references.table}(${contractFK.references.columns.join(", ")})`,
+        message: `Table "${tableName}" is missing foreign key: ${contractFK.columns.join(", ")} -> ${contractFK.references.table}(${contractFK.references.columns.join(", ")})`
+      });
+      nodes.push({
+        status: "fail",
+        kind: "foreignKey",
+        name: `foreignKey(${contractFK.columns.join(", ")})`,
+        contractPath: fkPath,
+        code: "foreign_key_mismatch",
+        message: "Foreign key missing",
+        expected: contractFK,
+        actual: void 0,
+        children: []
+      });
+    } else {
+      if (contractFK.name && matchingFK.name && contractFK.name !== matchingFK.name) {
+        issues.push({
+          kind: "foreign_key_mismatch",
+          table: tableName,
+          indexOrConstraint: contractFK.name,
+          expected: contractFK.name,
+          actual: matchingFK.name,
+          message: `Table "${tableName}" has foreign key name mismatch: expected "${contractFK.name}", got "${matchingFK.name}"`
+        });
+        nodes.push({
+          status: "fail",
+          kind: "foreignKey",
+          name: `foreignKey(${contractFK.columns.join(", ")})`,
+          contractPath: fkPath,
+          code: "foreign_key_mismatch",
+          message: "Foreign key name mismatch",
+          expected: contractFK.name,
+          actual: matchingFK.name,
+          children: []
+        });
+      } else {
+        nodes.push({
+          status: "pass",
+          kind: "foreignKey",
+          name: `foreignKey(${contractFK.columns.join(", ")})`,
+          contractPath: fkPath,
+          code: "",
+          message: "",
+          expected: void 0,
+          actual: void 0,
+          children: []
+        });
+      }
+    }
+  }
+  if (strict) {
+    for (const schemaFK of schemaFKs) {
+      const matchingFK = contractFKs.find((fk) => {
+        return arraysEqual(fk.columns, schemaFK.columns) && fk.references.table === schemaFK.referencedTable && arraysEqual(fk.references.columns, schemaFK.referencedColumns);
+      });
+      if (!matchingFK) {
+        issues.push({
+          kind: "extra_foreign_key",
+          table: tableName,
+          message: `Extra foreign key found in database (not in contract): ${schemaFK.columns.join(", ")} -> ${schemaFK.referencedTable}(${schemaFK.referencedColumns.join(", ")})`
+        });
+        nodes.push({
+          status: "fail",
+          kind: "foreignKey",
+          name: `foreignKey(${schemaFK.columns.join(", ")})`,
+          contractPath: `${tablePath}.foreignKeys[${schemaFK.columns.join(",")}]`,
+          code: "extra_foreign_key",
+          message: "Extra foreign key found",
+          expected: void 0,
+          actual: schemaFK,
+          children: []
+        });
+      }
+    }
+  }
+  return nodes;
+}
+function verifyUniqueConstraints(contractUniques, schemaUniques, tableName, tablePath, issues, strict) {
+  const nodes = [];
+  for (const contractUnique of contractUniques) {
+    const uniquePath = `${tablePath}.uniques[${contractUnique.columns.join(",")}]`;
+    const matchingUnique = schemaUniques.find(
+      (u) => arraysEqual(u.columns, contractUnique.columns)
+    );
+    if (!matchingUnique) {
+      issues.push({
+        kind: "unique_constraint_mismatch",
+        table: tableName,
+        expected: contractUnique.columns.join(", "),
+        message: `Table "${tableName}" is missing unique constraint: ${contractUnique.columns.join(", ")}`
+      });
+      nodes.push({
+        status: "fail",
+        kind: "unique",
+        name: `unique(${contractUnique.columns.join(", ")})`,
+        contractPath: uniquePath,
+        code: "unique_constraint_mismatch",
+        message: "Unique constraint missing",
+        expected: contractUnique,
+        actual: void 0,
+        children: []
+      });
+    } else {
+      if (contractUnique.name && matchingUnique.name && contractUnique.name !== matchingUnique.name) {
+        issues.push({
+          kind: "unique_constraint_mismatch",
+          table: tableName,
+          indexOrConstraint: contractUnique.name,
+          expected: contractUnique.name,
+          actual: matchingUnique.name,
+          message: `Table "${tableName}" has unique constraint name mismatch: expected "${contractUnique.name}", got "${matchingUnique.name}"`
+        });
+        nodes.push({
+          status: "fail",
+          kind: "unique",
+          name: `unique(${contractUnique.columns.join(", ")})`,
+          contractPath: uniquePath,
+          code: "unique_constraint_mismatch",
+          message: "Unique constraint name mismatch",
+          expected: contractUnique.name,
+          actual: matchingUnique.name,
+          children: []
+        });
+      } else {
+        nodes.push({
+          status: "pass",
+          kind: "unique",
+          name: `unique(${contractUnique.columns.join(", ")})`,
+          contractPath: uniquePath,
+          code: "",
+          message: "",
+          expected: void 0,
+          actual: void 0,
+          children: []
+        });
+      }
+    }
+  }
+  if (strict) {
+    for (const schemaUnique of schemaUniques) {
+      const matchingUnique = contractUniques.find(
+        (u) => arraysEqual(u.columns, schemaUnique.columns)
+      );
+      if (!matchingUnique) {
+        issues.push({
+          kind: "extra_unique_constraint",
+          table: tableName,
+          message: `Extra unique constraint found in database (not in contract): ${schemaUnique.columns.join(", ")}`
+        });
+        nodes.push({
+          status: "fail",
+          kind: "unique",
+          name: `unique(${schemaUnique.columns.join(", ")})`,
+          contractPath: `${tablePath}.uniques[${schemaUnique.columns.join(",")}]`,
+          code: "extra_unique_constraint",
+          message: "Extra unique constraint found",
+          expected: void 0,
+          actual: schemaUnique,
+          children: []
+        });
+      }
+    }
+  }
+  return nodes;
+}
+function verifyIndexes(contractIndexes, schemaIndexes, tableName, tablePath, issues, strict) {
+  const nodes = [];
+  for (const contractIndex of contractIndexes) {
+    const indexPath = `${tablePath}.indexes[${contractIndex.columns.join(",")}]`;
+    const matchingIndex = schemaIndexes.find(
+      (idx) => arraysEqual(idx.columns, contractIndex.columns) && idx.unique === false
+    );
+    if (!matchingIndex) {
+      issues.push({
+        kind: "index_mismatch",
+        table: tableName,
+        expected: contractIndex.columns.join(", "),
+        message: `Table "${tableName}" is missing index: ${contractIndex.columns.join(", ")}`
+      });
+      nodes.push({
+        status: "fail",
+        kind: "index",
+        name: `index(${contractIndex.columns.join(", ")})`,
+        contractPath: indexPath,
+        code: "index_mismatch",
+        message: "Index missing",
+        expected: contractIndex,
+        actual: void 0,
+        children: []
+      });
+    } else {
+      if (contractIndex.name && matchingIndex.name && contractIndex.name !== matchingIndex.name) {
+        issues.push({
+          kind: "index_mismatch",
+          table: tableName,
+          indexOrConstraint: contractIndex.name,
+          expected: contractIndex.name,
+          actual: matchingIndex.name,
+          message: `Table "${tableName}" has index name mismatch: expected "${contractIndex.name}", got "${matchingIndex.name}"`
+        });
+        nodes.push({
+          status: "fail",
+          kind: "index",
+          name: `index(${contractIndex.columns.join(", ")})`,
+          contractPath: indexPath,
+          code: "index_mismatch",
+          message: "Index name mismatch",
+          expected: contractIndex.name,
+          actual: matchingIndex.name,
+          children: []
+        });
+      } else {
+        nodes.push({
+          status: "pass",
+          kind: "index",
+          name: `index(${contractIndex.columns.join(", ")})`,
+          contractPath: indexPath,
+          code: "",
+          message: "",
+          expected: void 0,
+          actual: void 0,
+          children: []
+        });
+      }
+    }
+  }
+  if (strict) {
+    for (const schemaIndex of schemaIndexes) {
+      if (schemaIndex.unique) {
+        continue;
+      }
+      const matchingIndex = contractIndexes.find(
+        (idx) => arraysEqual(idx.columns, schemaIndex.columns)
+      );
+      if (!matchingIndex) {
+        issues.push({
+          kind: "extra_index",
+          table: tableName,
+          message: `Extra index found in database (not in contract): ${schemaIndex.columns.join(", ")}`
+        });
+        nodes.push({
+          status: "fail",
+          kind: "index",
+          name: `index(${schemaIndex.columns.join(", ")})`,
+          contractPath: `${tablePath}.indexes[${schemaIndex.columns.join(",")}]`,
+          code: "extra_index",
+          message: "Extra index found",
+          expected: void 0,
+          actual: schemaIndex,
+          children: []
+        });
+      }
+    }
+  }
+  return nodes;
+}
+function verifyExtensions(contractExtensions, schemaExtensions, contractTarget, issues, _strict) {
+  const nodes = [];
+  if (!contractExtensions) {
+    return nodes;
+  }
+  const contractExtensionNames = Object.keys(contractExtensions).filter(
+    (name) => name !== contractTarget
+  );
+  for (const extName of contractExtensionNames) {
+    const extPath = `extensions.${extName}`;
+    const normalizedExtName = extName.toLowerCase().replace(/^pg/, "");
+    const matchingExt = schemaExtensions.find((e) => {
+      const normalizedE = e.toLowerCase();
+      if (normalizedE === normalizedExtName || normalizedE === extName.toLowerCase()) {
+        return true;
+      }
+      if (normalizedE.includes(normalizedExtName) || normalizedExtName.includes(normalizedE)) {
+        return true;
+      }
+      return false;
+    });
+    const extensionLabels = {
+      pg: "database is postgres",
+      pgvector: "vector extension is enabled",
+      vector: "vector extension is enabled"
+    };
+    const extensionLabel = extensionLabels[extName] ?? `extension "${extName}" is enabled`;
+    if (!matchingExt) {
+      issues.push({
+        kind: "extension_missing",
+        table: "",
+        message: `Extension "${extName}" is missing from database`
+      });
+      nodes.push({
+        status: "fail",
+        kind: "extension",
+        name: extensionLabel,
+        contractPath: extPath,
+        code: "extension_missing",
+        message: `Extension "${extName}" is missing`,
+        expected: void 0,
+        actual: void 0,
+        children: []
+      });
+    } else {
+      nodes.push({
+        status: "pass",
+        kind: "extension",
+        name: extensionLabel,
+        contractPath: extPath,
+        code: "",
+        message: "",
+        expected: void 0,
+        actual: void 0,
+        children: []
+      });
+    }
+  }
+  return nodes;
+}
+function computeCounts(node) {
+  let pass = 0;
+  let warn = 0;
+  let fail = 0;
+  function traverse(n) {
+    if (n.status === "pass") {
+      pass++;
+    } else if (n.status === "warn") {
+      warn++;
+    } else if (n.status === "fail") {
+      fail++;
+    }
+    if (n.children) {
+      for (const child of n.children) {
+        traverse(child);
+      }
+    }
+  }
+  traverse(node);
+  return {
+    pass,
+    warn,
+    fail,
+    totalNodes: pass + warn + fail
+  };
+}
+
+// src/core/schema-verify/verify-sql-schema.ts
+function verifySqlSchema(options) {
+  const { contract, schema, strict, context, typeMetadataRegistry } = options;
+  const startTime = Date.now();
+  const contractCoreHash = contract.coreHash;
+  const contractProfileHash = "profileHash" in contract && typeof contract.profileHash === "string" ? contract.profileHash : void 0;
+  const contractTarget = contract.target;
+  const issues = [];
+  const rootChildren = [];
+  const contractTables = contract.storage.tables;
+  const schemaTables = schema.tables;
+  for (const [tableName, contractTable] of Object.entries(contractTables)) {
+    const schemaTable = schemaTables[tableName];
+    const tablePath = `storage.tables.${tableName}`;
+    if (!schemaTable) {
+      issues.push({
+        kind: "missing_table",
+        table: tableName,
+        message: `Table "${tableName}" is missing from database`
+      });
+      rootChildren.push({
+        status: "fail",
+        kind: "table",
+        name: `table ${tableName}`,
+        contractPath: tablePath,
+        code: "missing_table",
+        message: `Table "${tableName}" is missing`,
+        expected: void 0,
+        actual: void 0,
+        children: []
+      });
+      continue;
+    }
+    const tableChildren = [];
+    const columnNodes = [];
+    for (const [columnName, contractColumn] of Object.entries(contractTable.columns)) {
+      const schemaColumn = schemaTable.columns[columnName];
+      const columnPath = `${tablePath}.columns.${columnName}`;
+      if (!schemaColumn) {
+        issues.push({
+          kind: "missing_column",
+          table: tableName,
+          column: columnName,
+          message: `Column "${tableName}"."${columnName}" is missing from database`
+        });
+        columnNodes.push({
+          status: "fail",
+          kind: "column",
+          name: `${columnName}: missing`,
+          contractPath: columnPath,
+          code: "missing_column",
+          message: `Column "${columnName}" is missing`,
+          expected: void 0,
+          actual: void 0,
+          children: []
+        });
+        continue;
+      }
+      const columnChildren = [];
+      let columnStatus = "pass";
+      const contractNativeType = contractColumn.nativeType;
+      const schemaNativeType = schemaColumn.nativeType;
+      if (contractNativeType !== schemaNativeType) {
+        issues.push({
+          kind: "type_mismatch",
+          table: tableName,
+          column: columnName,
+          expected: contractNativeType,
+          actual: schemaNativeType,
+          message: `Column "${tableName}"."${columnName}" has type mismatch: expected "${contractNativeType}", got "${schemaNativeType}"`
+        });
+        columnChildren.push({
+          status: "fail",
+          kind: "type",
+          name: "type",
+          contractPath: `${columnPath}.nativeType`,
+          code: "type_mismatch",
+          message: `Type mismatch: expected ${contractNativeType}, got ${schemaNativeType}`,
+          expected: contractNativeType,
+          actual: schemaNativeType,
+          children: []
+        });
+        columnStatus = "fail";
+      }
+      if (contractColumn.codecId) {
+        const typeMetadata = typeMetadataRegistry.get(contractColumn.codecId);
+        if (!typeMetadata) {
+          columnChildren.push({
+            status: "warn",
+            kind: "type",
+            name: "type_metadata_missing",
+            contractPath: `${columnPath}.codecId`,
+            code: "type_metadata_missing",
+            message: `codecId "${contractColumn.codecId}" not found in type metadata registry`,
+            expected: contractColumn.codecId,
+            actual: void 0,
+            children: []
+          });
+        } else if (typeMetadata.nativeType && typeMetadata.nativeType !== contractNativeType) {
+          columnChildren.push({
+            status: "warn",
+            kind: "type",
+            name: "type_consistency",
+            contractPath: `${columnPath}.codecId`,
+            code: "type_consistency_warning",
+            message: `codecId "${contractColumn.codecId}" maps to nativeType "${typeMetadata.nativeType}" in registry, but contract has "${contractNativeType}"`,
+            expected: typeMetadata.nativeType,
+            actual: contractNativeType,
+            children: []
+          });
+        }
+      }
+      if (contractColumn.nullable !== schemaColumn.nullable) {
+        issues.push({
+          kind: "nullability_mismatch",
+          table: tableName,
+          column: columnName,
+          expected: String(contractColumn.nullable),
+          actual: String(schemaColumn.nullable),
+          message: `Column "${tableName}"."${columnName}" has nullability mismatch: expected ${contractColumn.nullable ? "nullable" : "not null"}, got ${schemaColumn.nullable ? "nullable" : "not null"}`
+        });
+        columnChildren.push({
+          status: "fail",
+          kind: "nullability",
+          name: "nullability",
+          contractPath: `${columnPath}.nullable`,
+          code: "nullability_mismatch",
+          message: `Nullability mismatch: expected ${contractColumn.nullable ? "nullable" : "not null"}, got ${schemaColumn.nullable ? "nullable" : "not null"}`,
+          expected: contractColumn.nullable,
+          actual: schemaColumn.nullable,
+          children: []
+        });
+        columnStatus = "fail";
+      }
+      const computedColumnStatus = columnChildren.some((c) => c.status === "fail") ? "fail" : columnChildren.some((c) => c.status === "warn") ? "warn" : "pass";
+      const finalColumnStatus = columnChildren.length > 0 ? computedColumnStatus : columnStatus;
+      const nullableText = contractColumn.nullable ? "nullable" : "not nullable";
+      const columnTypeDisplay = contractColumn.codecId ? `${contractNativeType} (${contractColumn.codecId})` : contractNativeType;
+      const failureMessages = columnChildren.filter((child) => child.status === "fail" && child.message).map((child) => child.message).filter((msg) => typeof msg === "string" && msg.length > 0);
+      const columnMessage = finalColumnStatus === "fail" && failureMessages.length > 0 ? failureMessages.join("; ") : "";
+      const columnCode = (finalColumnStatus === "fail" || finalColumnStatus === "warn") && columnChildren[0] ? columnChildren[0].code : "";
+      columnNodes.push({
+        status: finalColumnStatus,
+        kind: "column",
+        name: `${columnName}: ${columnTypeDisplay} (${nullableText})`,
+        contractPath: columnPath,
+        code: columnCode,
+        message: columnMessage,
+        expected: void 0,
+        actual: void 0,
+        children: columnChildren
+      });
+    }
+    if (columnNodes.length > 0) {
+      const columnsStatus = columnNodes.some((c) => c.status === "fail") ? "fail" : columnNodes.some((c) => c.status === "warn") ? "warn" : "pass";
+      tableChildren.push({
+        status: columnsStatus,
+        kind: "columns",
+        name: "columns",
+        contractPath: `${tablePath}.columns`,
+        code: "",
+        message: "",
+        expected: void 0,
+        actual: void 0,
+        children: columnNodes
+      });
+    }
+    if (strict) {
+      for (const [columnName, { nativeType }] of Object.entries(schemaTable.columns)) {
+        if (!contractTable.columns[columnName]) {
+          issues.push({
+            kind: "extra_column",
+            table: tableName,
+            column: columnName,
+            message: `Extra column "${tableName}"."${columnName}" found in database (not in contract)`
+          });
+          columnNodes.push({
+            status: "fail",
+            kind: "column",
+            name: `${columnName}: extra`,
+            contractPath: `${tablePath}.columns.${columnName}`,
+            code: "extra_column",
+            message: `Extra column "${columnName}" found`,
+            expected: void 0,
+            actual: nativeType,
+            children: []
+          });
+        }
+      }
+    }
+    if (contractTable.primaryKey) {
+      const pkStatus = verifyPrimaryKey(
+        contractTable.primaryKey,
+        schemaTable.primaryKey,
+        tableName,
+        issues
+      );
+      if (pkStatus === "fail") {
+        tableChildren.push({
+          status: "fail",
+          kind: "primaryKey",
+          name: `primary key: ${contractTable.primaryKey.columns.join(", ")}`,
+          contractPath: `${tablePath}.primaryKey`,
+          code: "primary_key_mismatch",
+          message: "Primary key mismatch",
+          expected: contractTable.primaryKey,
+          actual: schemaTable.primaryKey,
+          children: []
+        });
+      } else {
+        tableChildren.push({
+          status: "pass",
+          kind: "primaryKey",
+          name: `primary key: ${contractTable.primaryKey.columns.join(", ")}`,
+          contractPath: `${tablePath}.primaryKey`,
+          code: "",
+          message: "",
+          expected: void 0,
+          actual: void 0,
+          children: []
+        });
+      }
+    } else if (schemaTable.primaryKey && strict) {
+      issues.push({
+        kind: "extra_primary_key",
+        table: tableName,
+        message: "Extra primary key found in database (not in contract)"
+      });
+      tableChildren.push({
+        status: "fail",
+        kind: "primaryKey",
+        name: `primary key: ${schemaTable.primaryKey.columns.join(", ")}`,
+        contractPath: `${tablePath}.primaryKey`,
+        code: "extra_primary_key",
+        message: "Extra primary key found",
+        expected: void 0,
+        actual: schemaTable.primaryKey,
+        children: []
+      });
+    }
+    const fkStatuses = verifyForeignKeys(
+      contractTable.foreignKeys,
+      schemaTable.foreignKeys,
+      tableName,
+      tablePath,
+      issues,
+      strict
+    );
+    tableChildren.push(...fkStatuses);
+    const uniqueStatuses = verifyUniqueConstraints(
+      contractTable.uniques,
+      schemaTable.uniques,
+      tableName,
+      tablePath,
+      issues,
+      strict
+    );
+    tableChildren.push(...uniqueStatuses);
+    const indexStatuses = verifyIndexes(
+      contractTable.indexes,
+      schemaTable.indexes,
+      tableName,
+      tablePath,
+      issues,
+      strict
+    );
+    tableChildren.push(...indexStatuses);
+    const tableStatus = tableChildren.some((c) => c.status === "fail") ? "fail" : tableChildren.some((c) => c.status === "warn") ? "warn" : "pass";
+    const tableFailureMessages = tableChildren.filter((child) => child.status === "fail" && child.message).map((child) => child.message).filter((msg) => typeof msg === "string" && msg.length > 0);
+    const tableMessage = tableStatus === "fail" && tableFailureMessages.length > 0 ? `${tableFailureMessages.length} issue${tableFailureMessages.length === 1 ? "" : "s"}` : "";
+    const tableCode = tableStatus === "fail" && tableChildren.length > 0 && tableChildren[0] ? tableChildren[0].code : "";
+    rootChildren.push({
+      status: tableStatus,
+      kind: "table",
+      name: `table ${tableName}`,
+      contractPath: tablePath,
+      code: tableCode,
+      message: tableMessage,
+      expected: void 0,
+      actual: void 0,
+      children: tableChildren
+    });
+  }
+  if (strict) {
+    for (const tableName of Object.keys(schemaTables)) {
+      if (!contractTables[tableName]) {
+        issues.push({
+          kind: "extra_table",
+          table: tableName,
+          message: `Extra table "${tableName}" found in database (not in contract)`
+        });
+        rootChildren.push({
+          status: "fail",
+          kind: "table",
+          name: `table ${tableName}`,
+          contractPath: `storage.tables.${tableName}`,
+          code: "extra_table",
+          message: `Extra table "${tableName}" found`,
+          expected: void 0,
+          actual: void 0,
+          children: []
+        });
+      }
+    }
+  }
+  const extensionStatuses = verifyExtensions(
+    contract.extensions,
+    schema.extensions,
+    contractTarget,
+    issues,
+    strict
+  );
+  rootChildren.push(...extensionStatuses);
+  const rootStatus = rootChildren.some((c) => c.status === "fail") ? "fail" : rootChildren.some((c) => c.status === "warn") ? "warn" : "pass";
+  const root = {
+    status: rootStatus,
+    kind: "contract",
+    name: "contract",
+    contractPath: "",
+    code: "",
+    message: "",
+    expected: void 0,
+    actual: void 0,
+    children: rootChildren
+  };
+  const counts = computeCounts(root);
+  const ok = counts.fail === 0;
+  const code = ok ? void 0 : "PN-SCHEMA-0001";
+  const summary = ok ? "Database schema satisfies contract" : `Database schema does not satisfy contract (${counts.fail} failure${counts.fail === 1 ? "" : "s"})`;
+  const totalTime = Date.now() - startTime;
+  return {
+    ok,
+    ...ifDefined("code", code),
+    summary,
+    contract: {
+      coreHash: contractCoreHash,
+      ...ifDefined("profileHash", contractProfileHash)
+    },
+    target: {
+      expected: contractTarget,
+      actual: contractTarget
+    },
+    schema: {
+      issues,
+      root,
+      counts
+    },
+    meta: {
+      strict,
+      ...ifDefined("contractPath", context?.contractPath),
+      ...ifDefined("configPath", context?.configPath)
+    },
+    timings: {
+      total: totalTime
+    }
+  };
+}
+
+export {
+  verifySqlSchema
+};
+//# sourceMappingURL=chunk-I7QWTBWS.js.map