@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-J2OP5GG3.cjs

@@ -0,0 +1,725 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkD2ULAULScjs = require('./chunk-D2ULAULS.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkAWRISO2Hcjs = require('./chunk-AWRISO2H.cjs');
+
+
+var _chunkJSROZYYOcjs = require('./chunk-JSROZYYO.cjs');
+
+
+var _chunkZ5HIWVDPcjs = require('./chunk-Z5HIWVDP.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/schema-dependencies.ts
+function collectSchemaDependencies(owners) {
+  const names = new Set(owners.map((owner) => owner.name));
+  const known = /* @__PURE__ */ new Map();
+  const creators = /* @__PURE__ */ new Map();
+  const claimedKeys = /* @__PURE__ */ new Map();
+  for (const owner of owners) {
+    try {
+      known.set(owner.name, _chunkJSROZYYOcjs.resolveSchemaModels.call(void 0, owner.name, owner.schema));
+      for (const model of _chunkAWRISO2Hcjs.collectSchemaModels.call(void 0, [[owner.name, owner.schema, owner.models]])) {
+        creators.set(model.modelName.toLowerCase(), owner.name);
+        claimedKeys.set(model.modelKey, owner.name);
+      }
+    } catch (e) {
+    }
+  }
+  const referencedTable = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (owner, model) => {
+    const own = _optionalChain([known, 'access', _2 => _2.get, 'call', _3 => _3(owner), 'optionalAccess', _4 => _4[model]]);
+    if (own && Object.prototype.hasOwnProperty.call(known.get(owner), model)) return own.name;
+    const creator = claimedKeys.get(model);
+    return creator && _optionalChain([known, 'access', _5 => _5.get, 'call', _6 => _6(creator), 'optionalAccess', _7 => _7[model], 'optionalAccess', _8 => _8.name]) || model;
+  }, "referencedTable");
+  const dependencies = /* @__PURE__ */ new Map();
+  for (const owner of owners) {
+    const needs = new Set(
+      (_nullishCoalesce(owner.dependsOn, () => ( []))).filter((name) => names.has(name) && name !== owner.name)
+    );
+    dependencies.set(owner.name, needs);
+    const add = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (table) => {
+      const creator = creators.get(table.toLowerCase());
+      if (creator && creator !== owner.name) needs.add(creator);
+    }, "add");
+    try {
+      for (const model of _chunkAWRISO2Hcjs.collectSchemaModels.call(void 0, [[owner.name, owner.schema, owner.models]])) {
+        for (const field of Object.values(model.model.fields)) {
+          if (field.reference) add(referencedTable(owner.name, field.reference.model));
+        }
+      }
+      for (const extension of _chunkAWRISO2Hcjs.collectSchemaExtensions.call(void 0, owner.name, owner.schema, owner.models)) {
+        add(extension.table);
+      }
+    } catch (e2) {
+    }
+  }
+  return dependencies;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, collectSchemaDependencies, "collectSchemaDependencies");
+function orderSchemaOwners(owners, dependencies = collectSchemaDependencies(owners)) {
+  const byName = new Map(owners.map((owner) => [owner.name, owner]));
+  const ordered = [];
+  const state = /* @__PURE__ */ new Map();
+  const visit = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (owner) => {
+    if (state.has(owner.name)) return;
+    state.set(owner.name, "visiting");
+    for (const name of _nullishCoalesce(dependencies.get(owner.name), () => ( []))) {
+      const dependency = byName.get(name);
+      if (dependency && state.get(name) !== "visiting") visit(dependency);
+    }
+    state.set(owner.name, "done");
+    ordered.push(owner);
+  }, "visit");
+  for (const owner of owners) visit(owner);
+  return ordered;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, orderSchemaOwners, "orderSchemaOwners");
+
+// src/schema-check.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+async function withTimeout(work, timeoutMs) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`no answer within ${formatSeconds(timeoutMs)}`)),
+      timeoutMs
+    );
+    _optionalChain([timer, 'access', _9 => _9.unref, 'optionalCall', _10 => _10()]);
+  });
+  try {
+    return await Promise.race([Promise.resolve().then(work), timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, withTimeout, "withTimeout");
+var formatSeconds = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (ms) => ms < 1e3 ? `${ms}ms` : `${Number((ms / 1e3).toFixed(1))}s`, "formatSeconds");
+function collectSchemaOwners(config) {
+  const owners = [];
+  const integrationSchemas = _chunkZ5HIWVDPcjs.getIntegrationSchemas.call(void 0, config.integrations);
+  let integrationClient;
+  for (const [name, schema] of Object.entries(integrationSchemas)) {
+    owners.push({
+      name,
+      kind: "integration",
+      schema,
+      resolveClient: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (resolved) => _nullishCoalesce(integrationClient, () => ( (integrationClient = _chunkD2ULAULScjs.resolveIntegrationOrmRuntimeClient.call(void 0, { config: resolved })))), "resolveClient")
+    });
+  }
+  for (const declaration of _chunkAWRISO2Hcjs.findSchemaTableOwners.call(void 0, config)) {
+    if (owners.some((owner) => owner.name === declaration.name)) continue;
+    owners.push({
+      name: declaration.name,
+      kind: "plugin",
+      schema: declaration.schema,
+      models: declaration.models,
+      dialect: declaration.dialect,
+      dependsOn: declaration.dependsOn,
+      version: declaration.version,
+      migrations: declaration.migrations,
+      resolveClient: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (resolved) => declaration.resolveClient(resolved), "resolveClient")
+    });
+  }
+  return owners;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, collectSchemaOwners, "collectSchemaOwners");
+var errorMessage = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (error) => (error instanceof Error ? error.message : String(error)).replace(
+  /(\/\/[^/\s:@]+):[^@\s]+@/gu,
+  "$1:***@"
+), "errorMessage");
+function migrateHint(owner) {
+  return owner.kind === "plugin" ? `Run \`farm ${owner.name} migrate\` to see the SQL, then \`--apply\` it.` : "Create it with your migration tool: `farm generate` writes the integration's tables into your Prisma or Drizzle schema.";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, migrateHint, "migrateHint");
+function resolveSchemaExecutor(client, owner, timeoutMs) {
+  for (const candidate of [client, client.$client]) {
+    if (candidate === void 0 || candidate === null) continue;
+    let adapter;
+    try {
+      adapter = _chunkAWRISO2Hcjs.createSchemaExecutor.call(void 0, candidate, owner);
+    } catch (e3) {
+      continue;
+    }
+    if (!adapter) return null;
+    const { executor } = adapter;
+    return {
+      ...adapter,
+      client: candidate,
+      // Each query is bounded, not the whole check, so a large schema on a
+      // slow link still finishes while a dead connection fails fast.
+      executor: {
+        execute: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (sql) => withTimeout(() => executor.execute(sql), timeoutMs), "execute"),
+        query: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (sql, params) => withTimeout(() => executor.query(sql, params), timeoutMs), "query")
+      }
+    };
+  }
+  return void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveSchemaExecutor, "resolveSchemaExecutor");
+var describeReferencedTable = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (database, table) => _chunkAWRISO2Hcjs.describeSchemaTable.call(void 0, database.executor, database.dialect, table), "describeReferencedTable");
+async function checkSchema(config, options = {}) {
+  const timeoutMs = _nullishCoalesce(options.timeoutMs, () => ( DEFAULT_TIMEOUT_MS));
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new TypeError("timeoutMs must be a positive number of milliseconds.");
+  }
+  const timeoutHint = `Check that the database is reachable from here, or allow longer than ${formatSeconds(timeoutMs)} with \`--timeout <ms>\`.`;
+  const dependencies = collectSchemaDependencies(collectSchemaOwners(config));
+  const owners = orderSchemaOwners(collectSchemaOwners(config), dependencies);
+  const issues = [];
+  const declared = /* @__PURE__ */ new Map();
+  for (const candidate of _nullishCoalesce(config.plugins, () => ( []))) {
+    const declaration = _chunkAWRISO2Hcjs.readSchemaTables.call(void 0, candidate);
+    if (!declaration) continue;
+    const schemas = _nullishCoalesce(declared.get(declaration.name), () => ( []));
+    if (!schemas.includes(declaration.schema)) schemas.push(declaration.schema);
+    declared.set(declaration.name, schemas);
+  }
+  for (const [name, schemas] of declared) {
+    if (schemas.length < 2) continue;
+    issues.push({
+      severity: "error",
+      code: "owner-conflict",
+      owner: name,
+      message: `${schemas.length} plugins declare tables under the name "${name}", so \`farm ${name} migrate\` and this check only see the first.`,
+      hint: "Rename one of the plugins: the part of its name after the last `:` or `/` is its migrate command."
+    });
+  }
+  const summaries = [];
+  const knownModels = /* @__PURE__ */ new Map();
+  const ownedModels = /* @__PURE__ */ new Map();
+  for (const owner of owners) {
+    try {
+      knownModels.set(owner.name, _chunkJSROZYYOcjs.resolveSchemaModels.call(void 0, owner.name, owner.schema));
+      ownedModels.set(owner.name, _chunkAWRISO2Hcjs.collectSchemaModels.call(void 0, [[owner.name, owner.schema, owner.models]]));
+    } catch (error) {
+      issues.push({
+        severity: "error",
+        code: "schema-invalid",
+        owner: owner.name,
+        message: errorMessage(error)
+      });
+    }
+  }
+  const resolveTarget = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (ownerName, field) => {
+    const reference = field.reference;
+    if (!reference) return void 0;
+    const own = _optionalChain([knownModels, 'access', _11 => _11.get, 'call', _12 => _12(ownerName), 'optionalAccess', _13 => _13[reference.model]]);
+    const other = own ? void 0 : owners.find(
+      (owner) => owner.name !== ownerName && (_nullishCoalesce(ownedModels.get(owner.name), () => ( []))).some((entry) => entry.modelKey === reference.model)
+    );
+    const model = _nullishCoalesce(own, () => ( (other && _optionalChain([knownModels, 'access', _14 => _14.get, 'call', _15 => _15(other.name), 'optionalAccess', _16 => _16[reference.model]]))));
+    if (model) {
+      const claimedBy = _optionalChain([[...ownedModels], 'access', _17 => _17.find, 'call', _18 => _18(
+        ([, models]) => models.some((entry) => entry.modelName === model.name)
+      ), 'optionalAccess', _19 => _19[0]]);
+      return {
+        table: model.name,
+        column: _nullishCoalesce(_optionalChain([model, 'access', _20 => _20.fields, 'access', _21 => _21[reference.field], 'optionalAccess', _22 => _22.name]), () => ( reference.field)),
+        owner: claimedBy
+      };
+    }
+    return { table: reference.model, column: reference.field };
+  }, "resolveTarget");
+  const databases = /* @__PURE__ */ new Map();
+  for (const owner of owners) {
+    const models = ownedModels.get(owner.name);
+    if (!models) continue;
+    const summary = {
+      name: owner.name,
+      kind: owner.kind,
+      relational: true,
+      tables: models.map((model) => model.modelName),
+      dependsOn: [..._nullishCoalesce(dependencies.get(owner.name), () => ( []))]
+    };
+    summaries.push(summary);
+    let client;
+    try {
+      client = await withTimeout(() => owner.resolveClient(config), timeoutMs);
+    } catch (error) {
+      issues.push({
+        severity: "error",
+        code: "client-unavailable",
+        owner: owner.name,
+        message: `Could not connect to ${owner.name}'s database: ${errorMessage(error)}`,
+        hint: timeoutHint
+      });
+      continue;
+    }
+    if (client === void 0 || client === null) {
+      issues.push({
+        severity: "error",
+        code: "client-missing",
+        owner: owner.name,
+        message: `${owner.name} declares tables but has no database client.`,
+        hint: owner.kind === "integration" ? "Set `storage.client` in farm.config to your database client." : `Pass a database client to the ${owner.name} plugin.`
+      });
+      continue;
+    }
+    const adapter = resolveSchemaExecutor(client, owner.name, timeoutMs);
+    if (adapter === null) {
+      summary.relational = false;
+      continue;
+    }
+    if (adapter === void 0) {
+      issues.push({
+        severity: "warning",
+        code: "client-unsupported",
+        owner: owner.name,
+        message: `${owner.name}'s database client cannot be inspected, so its tables were not checked.`,
+        hint: "Farm reads pg, mysql2, and sqlite connections, and Drizzle databases built on them. Check these tables with your ORM's migration status instead."
+      });
+      continue;
+    }
+    const dialect = _nullishCoalesce(owner.dialect, () => ( adapter.dialect));
+    summary.dialect = dialect;
+    databases.set(owner.name, { client: adapter.client, executor: adapter.executor, dialect });
+  }
+  const claims = /* @__PURE__ */ new Map();
+  for (const [ownerName, models] of ownedModels) {
+    for (const model of models) {
+      const key = model.modelName.toLowerCase();
+      const previous = claims.get(key);
+      if (!previous || previous === ownerName) {
+        claims.set(key, ownerName);
+        continue;
+      }
+      const mine = databases.get(ownerName);
+      const theirs = databases.get(previous);
+      if (mine && theirs && mine.dialect !== theirs.dialect) continue;
+      if (_optionalChain([mine, 'optionalAccess', _23 => _23.dialect]) === "postgres" && _optionalChain([theirs, 'optionalAccess', _24 => _24.dialect]) === "postgres" && !(_nullishCoalesce(ownedModels.get(previous), () => ( []))).some((entry) => entry.modelName === model.modelName)) {
+        continue;
+      }
+      const shared = Boolean(mine && theirs && mine.client === theirs.client);
+      issues.push({
+        severity: shared ? "error" : "warning",
+        code: "table-conflict",
+        owner: ownerName,
+        table: model.modelName,
+        message: shared ? `"${model.modelName}" is claimed by both ${previous} and ${ownerName}.` : `"${model.modelName}" is claimed by both ${previous} and ${ownerName}. If they share a database, they write to the same table.`,
+        hint: "Give one of the models a different table name with `name`, or narrow one owner's `models`."
+      });
+    }
+  }
+  const allowExtend = _optionalChain([config, 'access', _25 => _25.schema, 'optionalAccess', _26 => _26.allowExtend]);
+  const extensions = /* @__PURE__ */ new Map();
+  const addedColumns = /* @__PURE__ */ new Map();
+  for (const owner of owners) {
+    if (!ownedModels.has(owner.name)) continue;
+    try {
+      const owned = _chunkAWRISO2Hcjs.collectSchemaExtensions.call(void 0, owner.name, owner.schema, owner.models);
+      extensions.set(owner.name, owned);
+      for (const extension of owned) {
+        for (const { field } of extension.fields) {
+          const key = `${extension.table}.${field.name}`.toLowerCase();
+          const other = addedColumns.get(key);
+          if (other && other !== owner.name) {
+            issues.push({
+              severity: "warning",
+              code: "extend-column-shared",
+              owner: owner.name,
+              table: extension.table,
+              column: field.name,
+              message: `${other} and ${owner.name} both add "${extension.table}.${field.name}", so they will share one column.`
+            });
+          } else {
+            addedColumns.set(key, owner.name);
+          }
+        }
+      }
+    } catch (error) {
+      issues.push({
+        severity: "error",
+        code: "extend-invalid",
+        owner: owner.name,
+        message: errorMessage(error)
+      });
+    }
+  }
+  const databaseForTable = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (table) => {
+    const creator = _optionalChain([[...ownedModels], 'access', _27 => _27.find, 'call', _28 => _28(
+      ([, models]) => models.some((model) => model.modelName === table)
+    ), 'optionalAccess', _29 => _29[0]]);
+    return creator ? databases.get(creator) : void 0;
+  }, "databaseForTable");
+  for (const owner of owners) {
+    const models = ownedModels.get(owner.name);
+    const database = databases.get(owner.name);
+    if (!models || !database) continue;
+    try {
+      const crossOwner = await _chunkAWRISO2Hcjs.planCrossOwnerReferences.call(void 0, 
+        owner,
+        _chunkAWRISO2Hcjs.findSchemaTableOwners.call(void 0, config),
+        database.dialect,
+        database.executor
+      );
+      for (const reference of crossOwner.eligible) {
+        const model = models.find((candidate) => candidate.modelKey === reference.modelKey);
+        if (!model) continue;
+        (_nullishCoalesce(model.foreignKeys, () => ( (model.foreignKeys = {}))))[reference.fieldKey] = {
+          table: reference.referencedTable,
+          column: reference.referencedColumn,
+          onDelete: reference.onDelete
+        };
+      }
+      const stepPlan = _optionalChain([owner, 'access', _30 => _30.migrations, 'optionalAccess', _31 => _31.length]) ? await _chunkAWRISO2Hcjs.planOwnerSchemaSteps.call(void 0, {
+        owner: owner.name,
+        schema: owner.schema,
+        steps: owner.migrations,
+        tables: models.map((model) => model.modelName),
+        dialect: database.dialect,
+        executor: database.executor,
+        othersTables: new Set(
+          [...ownedModels].filter(([name]) => name !== owner.name).flatMap(([, entries]) => entries.map((entry) => entry.modelName))
+        )
+      }) : void 0;
+      checkSteps(owner, stepPlan, issues);
+      const plan = await checkOwnerTables(
+        owner,
+        // What a pending rename will produce is not missing yet.
+        _chunkAWRISO2Hcjs.withoutRenameTargets.call(void 0, models, stepPlan),
+        database.dialect,
+        database.executor,
+        issues
+      );
+      const pending = plan.statements.length + (_nullishCoalesce(_optionalChain([plan, 'access', _32 => _32.upgrades, 'optionalAccess', _33 => _33.length]), () => ( 0)));
+      const state = pending > 0 ? await _chunkAWRISO2Hcjs.readSchemaState.call(void 0, database.executor, database.dialect, owner.name) : void 0;
+      const changes = state ? _chunkAWRISO2Hcjs.diffSchemaSnapshots.call(void 0, state.snapshot, _chunkAWRISO2Hcjs.createSchemaSnapshot.call(void 0, models)) : void 0;
+      if (state && changes && _chunkAWRISO2Hcjs.hasSchemaChanges.call(void 0, changes)) {
+        const versions = state.version && owner.version && state.version !== owner.version ? `upgraded ${state.version} \u2192 ${owner.version}` : "changed since it was last migrated";
+        issues.push({
+          severity: "warning",
+          code: "schema-upgrade",
+          owner: owner.name,
+          message: `${owner.name} ${versions}, and ${pending} change(s) are not applied yet.`,
+          hint: owner.kind === "plugin" ? `Run \`farm ${owner.name} migrate\` to review and apply them.` : "Apply them with your migration tool."
+        });
+      }
+      await checkReferences(owner, models, database, databases, resolveTarget, issues);
+      await checkExtensions(
+        owner,
+        _nullishCoalesce(extensions.get(owner.name), () => ( [])),
+        databaseForTable,
+        database,
+        allowExtend,
+        issues
+      );
+    } catch (error) {
+      issues.push({
+        severity: "error",
+        code: "client-unavailable",
+        owner: owner.name,
+        message: `Could not read ${owner.name}'s tables: ${errorMessage(error)}`,
+        hint: timeoutHint
+      });
+    }
+  }
+  return {
+    owners: summaries,
+    issues,
+    ok: !issues.some((issue) => issue.severity === "error")
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, checkSchema, "checkSchema");
+async function checkOwnerTables(owner, models, dialect, executor, issues) {
+  const plan = await _chunkAWRISO2Hcjs.planSchemaMigration.call(void 0, models, dialect, executor);
+  const present = /* @__PURE__ */ new Set([
+    ...plan.upToDate,
+    ...plan.drift.map((drift) => drift.table),
+    ...(_nullishCoalesce(plan.upgrades, () => ( []))).map((upgrade) => upgrade.table)
+  ]);
+  const command = owner.kind === "plugin" ? `\`farm ${owner.name} migrate\`` : "your migration tool";
+  for (const upgrade of _nullishCoalesce(plan.upgrades, () => ( []))) {
+    const column = upgrade.kind === "column" ? upgrade.target.slice(upgrade.table.length + 1) : void 0;
+    issues.push({
+      severity: column ? "error" : "warning",
+      code: column ? "column-missing" : "index-missing",
+      owner: owner.name,
+      table: upgrade.table,
+      ...column ? { column } : {},
+      message: column ? `"${upgrade.table}" has no column "${column}".` : `"${upgrade.table}" is missing the index ${upgrade.target}.`,
+      hint: `Add it with ${command}.`
+    });
+  }
+  for (const model of models) {
+    if (present.has(model.modelName)) continue;
+    issues.push({
+      severity: "error",
+      code: "table-missing",
+      owner: owner.name,
+      table: model.modelName,
+      message: `Table "${model.modelName}" does not exist.`,
+      hint: migrateHint(owner)
+    });
+  }
+  for (const drift of plan.drift) {
+    for (const column of drift.missingColumns) {
+      issues.push({
+        severity: "error",
+        code: "column-missing",
+        owner: owner.name,
+        table: drift.table,
+        column,
+        message: `"${drift.table}" has no column "${column}".`,
+        hint: "It is required with no default, so Farm cannot add it to a table that may have rows. Add it with a migration step or your migration tool."
+      });
+    }
+    for (const change of drift.changedColumns) {
+      const typeChanged = change.differences.includes("type");
+      issues.push({
+        severity: typeChanged ? "error" : "warning",
+        code: typeChanged ? "column-type" : "column-definition",
+        owner: owner.name,
+        table: drift.table,
+        column: change.column,
+        message: typeChanged ? `"${drift.table}.${change.column}" is ${change.actual.type}; the schema expects ${change.expected.type}.` : `"${drift.table}.${change.column}" differs from the schema (${change.differences.join(", ")}).`
+      });
+    }
+    for (const index of drift.missingIndexes) {
+      issues.push({
+        severity: "warning",
+        code: "index-missing",
+        owner: owner.name,
+        table: drift.table,
+        message: `"${drift.table}" is missing the ${index.unique ? "unique " : ""}index on (${index.columns.join(", ")}).`
+      });
+    }
+    for (const reference of _nullishCoalesce(drift.missingReferences, () => ( []))) {
+      issues.push({
+        severity: "warning",
+        code: "foreign-key-missing",
+        owner: owner.name,
+        table: drift.table,
+        column: reference.column,
+        message: `"${drift.table}.${reference.column}" has no foreign key to "${reference.referencedTable}.${reference.referencedColumn}".`
+      });
+    }
+  }
+  for (const key of _nullishCoalesce(plan.addableForeignKeys, () => ( []))) {
+    issues.push({
+      severity: "warning",
+      code: "foreign-key-missing",
+      owner: owner.name,
+      table: key.table,
+      column: key.column,
+      message: `"${key.table}.${key.column}" has no foreign key to "${key.referencedTable}.${key.referencedColumn}", which ${owner.name} could have.`,
+      hint: dialect === "sqlite" ? "SQLite can only add a foreign key when it creates the table." : `Allow it with \`${_chunkAWRISO2Hcjs.describeForeignKeyApproval.call(void 0, { owner: owner.name, modelKey: key.modelKey })}\` in farm.config, then run \`farm ${owner.name} migrate --apply\`. Rows that point at nothing are checked first.`
+    });
+  }
+  return plan;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, checkOwnerTables, "checkOwnerTables");
+function checkSteps(owner, stepPlan, issues) {
+  if (!stepPlan) return;
+  const command = `\`farm ${owner.name} migrate\``;
+  const blockedAt = stepPlan.steps.findIndex((planned) => planned.state === "blocked");
+  const pending = stepPlan.steps.slice(0, blockedAt === -1 ? void 0 : blockedAt).filter((planned) => planned.state === "run");
+  if (pending.length > 0) {
+    issues.push({
+      severity: "warning",
+      code: "migration-step-pending",
+      owner: owner.name,
+      message: `${owner.name} has ${pending.length} migration step(s) not run yet: ${pending.map((planned) => `${planned.summary}${planned.destructive ? " (deletes data)" : ""}`).join("; ")}.`,
+      hint: `Run ${command} to review and apply them.`
+    });
+  }
+  if (blockedAt !== -1) {
+    const blocked = stepPlan.steps[blockedAt];
+    issues.push({
+      severity: "error",
+      code: "migration-step-blocked",
+      owner: owner.name,
+      message: `${owner.name}'s migration step "${blocked.step.id}" (${blocked.summary}) cannot run: ${blocked.reason}`,
+      hint: "Later steps wait for it. Fix the database, then run migrate again."
+    });
+  }
+  for (const id of stepPlan.edited) {
+    issues.push({
+      severity: "warning",
+      code: "migration-step-edited",
+      owner: owner.name,
+      message: `${owner.name}'s migration step "${id}" changed after it ran here; it will not run again.`
+    });
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, checkSteps, "checkSteps");
+async function checkReferences(owner, models, database, databases, resolveTarget, issues) {
+  const ownTables = new Set(models.map((model) => model.modelName));
+  const described = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    for (const field of Object.values(model.model.fields)) {
+      const target = resolveTarget(owner.name, field);
+      if (!target || ownTables.has(target.table)) continue;
+      const targetDatabase = target.owner ? databases.get(target.owner) : database;
+      if (!targetDatabase) continue;
+      const key = `${_nullishCoalesce(target.owner, () => ( ""))}\0${target.table}`;
+      if (!described.has(key)) {
+        described.set(key, await describeReferencedTable(targetDatabase, target.table));
+      }
+      const table = described.get(key);
+      const dialect = targetDatabase.dialect;
+      const where = `"${model.modelName}.${field.name}" references "${target.table}.${target.column}"`;
+      if (!table) {
+        issues.push({
+          severity: "error",
+          code: "reference-table-missing",
+          owner: owner.name,
+          table: model.modelName,
+          column: field.name,
+          message: `${where}, but "${target.table}" does not exist.`,
+          hint: target.owner ? `It belongs to ${target.owner}; migrate it first.` : "Farm does not manage that table. Run the migration that creates it (your ORM's, or a library's such as Better Auth) first."
+        });
+        continue;
+      }
+      const column = table.columns.find(
+        (candidate) => dialect === "postgres" ? candidate.name === target.column : candidate.name.toLowerCase() === target.column.toLowerCase()
+      );
+      if (!column) {
+        issues.push({
+          severity: "error",
+          code: "reference-column-missing",
+          owner: owner.name,
+          table: model.modelName,
+          column: field.name,
+          message: `${where}, but "${target.table}" has no column "${target.column}".`,
+          hint: `Columns there: ${table.columns.map((candidate) => candidate.name).join(", ")}.`
+        });
+        continue;
+      }
+      if (database.dialect === "sqlite" || dialect === "sqlite") continue;
+      const expected = _chunkAWRISO2Hcjs.getSqlColumnType.call(void 0, field, database.dialect);
+      const mine = _chunkAWRISO2Hcjs.columnTypeFamily.call(void 0, expected);
+      const theirs = _chunkAWRISO2Hcjs.columnTypeFamily.call(void 0, column.type);
+      if (mine && theirs && mine !== theirs) {
+        issues.push({
+          severity: "warning",
+          code: "reference-type",
+          owner: owner.name,
+          table: model.modelName,
+          column: field.name,
+          message: `${where}, but the types differ: ${expected.toLowerCase()} here, ${column.type} there. Lookups by value work; a SQL join needs a cast and a foreign key is not possible.`,
+          hint: theirs === "uuid" && mine === "text" ? 'Farm stores "uuid" fields as text in Postgres. Cast in joins, for example "users"."id"::text.' : `Change "${field.name}" to match "${target.table}.${target.column}" if you join on it.`
+        });
+      }
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, checkReferences, "checkReferences");
+async function checkExtensions(owner, extensions, databaseForTable, ownDatabase, allowExtend, issues) {
+  for (const extension of extensions) {
+    const database = _nullishCoalesce(databaseForTable(extension.table), () => ( ownDatabase));
+    const table = await _chunkAWRISO2Hcjs.describeSchemaTable.call(void 0, database.executor, database.dialect, extension.table);
+    const columns = extension.fields.map(({ field }) => field.name);
+    if (!table) {
+      issues.push({
+        severity: "error",
+        code: "extend-table-missing",
+        owner: owner.name,
+        table: extension.table,
+        message: `${owner.name} adds ${columns.map((column) => `"${column}"`).join(", ")} to "${extension.table}", which does not exist.`,
+        hint: "Run the migration that creates it (your ORM's, or a library's such as Better Auth) first."
+      });
+      continue;
+    }
+    const allowed = _chunkAWRISO2Hcjs.isSchemaExtensionAllowed.call(void 0, allowExtend, extension);
+    for (const { field } of extension.fields) {
+      const existing = table.columns.find(
+        (column) => database.dialect === "postgres" ? column.name === field.name : column.name.toLowerCase() === field.name.toLowerCase()
+      );
+      if (!existing) {
+        const command = owner.kind === "plugin" ? `\`farm ${owner.name} migrate --apply\`` : "your migration tool";
+        issues.push({
+          severity: "error",
+          code: "extend-column-missing",
+          owner: owner.name,
+          table: extension.table,
+          column: field.name,
+          message: `${owner.name} needs "${extension.table}.${field.name}", which does not exist.`,
+          hint: allowed ? `Add it with ${command}. If your ORM owns "${extension.table}", add the column to its schema instead.` : `Allow it in farm.config with \`${_chunkAWRISO2Hcjs.describeSchemaExtensionApproval.call(void 0, extension)}\`, then add it with ${command}. If your ORM owns "${extension.table}", add the column to its schema instead.`
+        });
+        continue;
+      }
+      if (database.dialect === "sqlite") continue;
+      const expected = _chunkAWRISO2Hcjs.getSqlColumnType.call(void 0, field, database.dialect);
+      const mine = _chunkAWRISO2Hcjs.columnTypeFamily.call(void 0, expected);
+      const theirs = _chunkAWRISO2Hcjs.columnTypeFamily.call(void 0, existing.type);
+      if (mine && theirs && mine !== theirs) {
+        issues.push({
+          severity: "warning",
+          code: "extend-column-type",
+          owner: owner.name,
+          table: extension.table,
+          column: field.name,
+          message: `"${extension.table}.${field.name}" is ${existing.type}; ${owner.name} expects ${expected.toLowerCase()}.`
+        });
+      }
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, checkExtensions, "checkExtensions");
+function formatSchemaCheck(report) {
+  if (report.owners.length === 0) {
+    return "No integration or plugin declares database tables.";
+  }
+  const lines = [];
+  for (const owner of report.owners) {
+    const ownIssues = report.issues.filter((issue) => issue.owner === owner.name);
+    const details = [
+      owner.kind,
+      ...owner.dialect ? [owner.dialect] : [],
+      ..._optionalChain([owner, 'access', _34 => _34.dependsOn, 'optionalAccess', _35 => _35.length]) ? [`needs ${owner.dependsOn.join(", ")}`] : []
+    ];
+    const label = `${owner.name} (${details.join(", ")})`;
+    if (!owner.relational) {
+      lines.push(`- ${label}: stores data in a key/value mount, nothing to check`);
+      continue;
+    }
+    lines.push(
+      ownIssues.length === 0 ? `\u2713 ${label}: ${owner.tables.length} table(s) match` : `${ownIssues.some((issue) => issue.severity === "error") ? "\u2717" : "!"} ${label}`
+    );
+    for (const issue of ownIssues) {
+      lines.push(`    ${issue.severity === "error" ? "error  " : "warning"} ${issue.message}`);
+      if (issue.hint) lines.push(`            ${issue.hint}`);
+    }
+  }
+  for (const issue of report.issues.filter(
+    (candidate) => !report.owners.some((owner) => owner.name === candidate.owner)
+  )) {
+    lines.push(`\u2717 ${issue.owner}: ${issue.message}`);
+  }
+  const errors = report.issues.filter((issue) => issue.severity === "error").length;
+  const warnings = report.issues.length - errors;
+  lines.push("", `${errors} error(s), ${warnings} warning(s)`);
+  return lines.join("\n");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, formatSchemaCheck, "formatSchemaCheck");
+
+
+
+
+
+
+
+exports.collectSchemaDependencies = collectSchemaDependencies; exports.orderSchemaOwners = orderSchemaOwners; exports.collectSchemaOwners = collectSchemaOwners; exports.checkSchema = checkSchema; exports.formatSchemaCheck = formatSchemaCheck;