@prisma-next/family-sql 0.3.0-pr.93.5 → 0.3.0-pr.94.2

package/dist/chunk-XH2Y5NTD.js

@@ -1,715 +0,0 @@
-// 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 isUniqueConstraintSatisfied(uniques, indexes, columns) {
-  const hasConstraint = uniques.some((unique) => arraysEqual(unique.columns, columns));
-  if (hasConstraint) {
-    return true;
-  }
-  return indexes.some((index) => index.unique && arraysEqual(index.columns, columns));
-}
-function isIndexSatisfied(indexes, uniques, columns) {
-  const hasMatchingIndex = indexes.some((index) => arraysEqual(index.columns, columns));
-  if (hasMatchingIndex) {
-    return true;
-  }
-  return uniques.some((unique) => arraysEqual(unique.columns, columns));
-}
-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";
-  }
-  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 {
-      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, schemaIndexes, 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)
-    );
-    const matchingUniqueIndex = !matchingUnique && schemaIndexes.find((idx) => idx.unique && arraysEqual(idx.columns, contractUnique.columns));
-    if (!matchingUnique && !matchingUniqueIndex) {
-      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 {
-      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, schemaUniques, 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)
-    );
-    const matchingUniqueConstraint = !matchingIndex && schemaUniques.find((u) => arraysEqual(u.columns, contractIndex.columns));
-    if (!matchingIndex && !matchingUniqueConstraint) {
-      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 {
-      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 verifyDatabaseDependencies(dependencies, schema, issues) {
-  const nodes = [];
-  for (const dependency of dependencies) {
-    const depIssues = dependency.verifyDatabaseDependencyInstalled(schema);
-    const depPath = `dependencies.${dependency.id}`;
-    if (depIssues.length > 0) {
-      issues.push(...depIssues);
-      const issuesMessage = depIssues.map((i) => i.message).join("; ");
-      const nodeMessage = issuesMessage ? `${dependency.id}: ${issuesMessage}` : dependency.id;
-      nodes.push({
-        status: "fail",
-        kind: "databaseDependency",
-        name: dependency.label,
-        contractPath: depPath,
-        code: "dependency_missing",
-        message: nodeMessage,
-        expected: void 0,
-        actual: void 0,
-        children: []
-      });
-    } else {
-      nodes.push({
-        status: "pass",
-        kind: "databaseDependency",
-        name: dependency.label,
-        contractPath: depPath,
-        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
-import { ifDefined } from "@prisma-next/utils/defined";
-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,
-      schemaTable.indexes,
-      tableName,
-      tablePath,
-      issues,
-      strict
-    );
-    tableChildren.push(...uniqueStatuses);
-    const indexStatuses = verifyIndexes(
-      contractTable.indexes,
-      schemaTable.indexes,
-      schemaTable.uniques,
-      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 contractExtensionPacks = contract.extensionPacks ?? {};
-  for (const extensionNamespace of Object.keys(contractExtensionPacks)) {
-    const hasComponent = options.frameworkComponents.some(
-      (component) => component.id === extensionNamespace && (component.kind === "extension" || component.kind === "adapter" || component.kind === "target")
-    );
-    if (!hasComponent) {
-      throw new Error(
-        `Extension pack '${extensionNamespace}' is declared in the contract but not found in framework components. This indicates a configuration mismatch - the contract was emitted with this extension pack, but it is not provided in the current configuration.`
-      );
-    }
-  }
-  const databaseDependencies = collectDependenciesFromFrameworkComponents(
-    options.frameworkComponents
-  );
-  const dependencyStatuses = verifyDatabaseDependencies(databaseDependencies, schema, issues);
-  rootChildren.push(...dependencyStatuses);
-  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
-    }
-  };
-}
-function hasDatabaseDependenciesInit(component) {
-  if (!("databaseDependencies" in component)) {
-    return false;
-  }
-  const dbDeps = component["databaseDependencies"];
-  if (dbDeps === void 0 || dbDeps === null || typeof dbDeps !== "object") {
-    return false;
-  }
-  const depsRecord = dbDeps;
-  const init = depsRecord["init"];
-  if (init === void 0 || !Array.isArray(init)) {
-    return false;
-  }
-  return true;
-}
-function collectDependenciesFromFrameworkComponents(components) {
-  const dependencies = [];
-  for (const component of components) {
-    if (hasDatabaseDependenciesInit(component)) {
-      dependencies.push(...component.databaseDependencies.init);
-    }
-  }
-  return dependencies;
-}
-
-export {
-  arraysEqual,
-  isUniqueConstraintSatisfied,
-  isIndexSatisfied,
-  verifyDatabaseDependencies,
-  verifySqlSchema
-};
-//# sourceMappingURL=chunk-XH2Y5NTD.js.map