@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-VILIPRS6.mjs

@@ -0,0 +1,725 @@
+import {
+  resolveIntegrationOrmRuntimeClient
+} from "./chunk-QV4VE2OW.mjs";
+import {
+  collectSchemaExtensions,
+  collectSchemaModels,
+  columnTypeFamily,
+  createSchemaExecutor,
+  createSchemaSnapshot,
+  describeForeignKeyApproval,
+  describeSchemaExtensionApproval,
+  describeSchemaTable,
+  diffSchemaSnapshots,
+  findSchemaTableOwners,
+  getSqlColumnType,
+  hasSchemaChanges,
+  isSchemaExtensionAllowed,
+  planCrossOwnerReferences,
+  planOwnerSchemaSteps,
+  planSchemaMigration,
+  readSchemaState,
+  readSchemaTables,
+  withoutRenameTargets
+} from "./chunk-HALDNTIV.mjs";
+import {
+  resolveSchemaModels
+} from "./chunk-ZMSZZXOR.mjs";
+import {
+  getIntegrationSchemas
+} from "./chunk-MKYBIIAQ.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// 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, resolveSchemaModels(owner.name, owner.schema));
+      for (const model of collectSchemaModels([[owner.name, owner.schema, owner.models]])) {
+        creators.set(model.modelName.toLowerCase(), owner.name);
+        claimedKeys.set(model.modelKey, owner.name);
+      }
+    } catch {
+    }
+  }
+  const referencedTable = /* @__PURE__ */ __name((owner, model) => {
+    const own = known.get(owner)?.[model];
+    if (own && Object.prototype.hasOwnProperty.call(known.get(owner), model)) return own.name;
+    const creator = claimedKeys.get(model);
+    return creator && known.get(creator)?.[model]?.name || model;
+  }, "referencedTable");
+  const dependencies = /* @__PURE__ */ new Map();
+  for (const owner of owners) {
+    const needs = new Set(
+      (owner.dependsOn ?? []).filter((name) => names.has(name) && name !== owner.name)
+    );
+    dependencies.set(owner.name, needs);
+    const add = /* @__PURE__ */ __name((table) => {
+      const creator = creators.get(table.toLowerCase());
+      if (creator && creator !== owner.name) needs.add(creator);
+    }, "add");
+    try {
+      for (const model of collectSchemaModels([[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 collectSchemaExtensions(owner.name, owner.schema, owner.models)) {
+        add(extension.table);
+      }
+    } catch {
+    }
+  }
+  return dependencies;
+}
+__name(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__ */ __name((owner) => {
+    if (state.has(owner.name)) return;
+    state.set(owner.name, "visiting");
+    for (const name of 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;
+}
+__name(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
+    );
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([Promise.resolve().then(work), timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+__name(withTimeout, "withTimeout");
+var formatSeconds = /* @__PURE__ */ __name((ms) => ms < 1e3 ? `${ms}ms` : `${Number((ms / 1e3).toFixed(1))}s`, "formatSeconds");
+function collectSchemaOwners(config) {
+  const owners = [];
+  const integrationSchemas = getIntegrationSchemas(config.integrations);
+  let integrationClient;
+  for (const [name, schema] of Object.entries(integrationSchemas)) {
+    owners.push({
+      name,
+      kind: "integration",
+      schema,
+      resolveClient: /* @__PURE__ */ __name((resolved) => integrationClient ?? (integrationClient = resolveIntegrationOrmRuntimeClient({ config: resolved })), "resolveClient")
+    });
+  }
+  for (const declaration of findSchemaTableOwners(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__ */ __name((resolved) => declaration.resolveClient(resolved), "resolveClient")
+    });
+  }
+  return owners;
+}
+__name(collectSchemaOwners, "collectSchemaOwners");
+var errorMessage = /* @__PURE__ */ __name((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.";
+}
+__name(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 = createSchemaExecutor(candidate, owner);
+    } catch {
+      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__ */ __name((sql) => withTimeout(() => executor.execute(sql), timeoutMs), "execute"),
+        query: /* @__PURE__ */ __name((sql, params) => withTimeout(() => executor.query(sql, params), timeoutMs), "query")
+      }
+    };
+  }
+  return void 0;
+}
+__name(resolveSchemaExecutor, "resolveSchemaExecutor");
+var describeReferencedTable = /* @__PURE__ */ __name((database, table) => describeSchemaTable(database.executor, database.dialect, table), "describeReferencedTable");
+async function checkSchema(config, options = {}) {
+  const timeoutMs = 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 config.plugins ?? []) {
+    const declaration = readSchemaTables(candidate);
+    if (!declaration) continue;
+    const schemas = 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, resolveSchemaModels(owner.name, owner.schema));
+      ownedModels.set(owner.name, collectSchemaModels([[owner.name, owner.schema, owner.models]]));
+    } catch (error) {
+      issues.push({
+        severity: "error",
+        code: "schema-invalid",
+        owner: owner.name,
+        message: errorMessage(error)
+      });
+    }
+  }
+  const resolveTarget = /* @__PURE__ */ __name((ownerName, field) => {
+    const reference = field.reference;
+    if (!reference) return void 0;
+    const own = knownModels.get(ownerName)?.[reference.model];
+    const other = own ? void 0 : owners.find(
+      (owner) => owner.name !== ownerName && (ownedModels.get(owner.name) ?? []).some((entry) => entry.modelKey === reference.model)
+    );
+    const model = own ?? (other && knownModels.get(other.name)?.[reference.model]);
+    if (model) {
+      const claimedBy = [...ownedModels].find(
+        ([, models]) => models.some((entry) => entry.modelName === model.name)
+      )?.[0];
+      return {
+        table: model.name,
+        column: model.fields[reference.field]?.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: [...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 = 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 (mine?.dialect === "postgres" && theirs?.dialect === "postgres" && !(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 = config.schema?.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 = collectSchemaExtensions(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__ */ __name((table) => {
+    const creator = [...ownedModels].find(
+      ([, models]) => models.some((model) => model.modelName === table)
+    )?.[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 planCrossOwnerReferences(
+        owner,
+        findSchemaTableOwners(config),
+        database.dialect,
+        database.executor
+      );
+      for (const reference of crossOwner.eligible) {
+        const model = models.find((candidate) => candidate.modelKey === reference.modelKey);
+        if (!model) continue;
+        (model.foreignKeys ?? (model.foreignKeys = {}))[reference.fieldKey] = {
+          table: reference.referencedTable,
+          column: reference.referencedColumn,
+          onDelete: reference.onDelete
+        };
+      }
+      const stepPlan = owner.migrations?.length ? await planOwnerSchemaSteps({
+        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.
+        withoutRenameTargets(models, stepPlan),
+        database.dialect,
+        database.executor,
+        issues
+      );
+      const pending = plan.statements.length + (plan.upgrades?.length ?? 0);
+      const state = pending > 0 ? await readSchemaState(database.executor, database.dialect, owner.name) : void 0;
+      const changes = state ? diffSchemaSnapshots(state.snapshot, createSchemaSnapshot(models)) : void 0;
+      if (state && changes && hasSchemaChanges(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,
+        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")
+  };
+}
+__name(checkSchema, "checkSchema");
+async function checkOwnerTables(owner, models, dialect, executor, issues) {
+  const plan = await planSchemaMigration(models, dialect, executor);
+  const present = /* @__PURE__ */ new Set([
+    ...plan.upToDate,
+    ...plan.drift.map((drift) => drift.table),
+    ...(plan.upgrades ?? []).map((upgrade) => upgrade.table)
+  ]);
+  const command = owner.kind === "plugin" ? `\`farm ${owner.name} migrate\`` : "your migration tool";
+  for (const upgrade of 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 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 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 \`${describeForeignKeyApproval({ 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;
+}
+__name(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.`
+    });
+  }
+}
+__name(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 = `${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 = getSqlColumnType(field, database.dialect);
+      const mine = columnTypeFamily(expected);
+      const theirs = columnTypeFamily(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.`
+        });
+      }
+    }
+  }
+}
+__name(checkReferences, "checkReferences");
+async function checkExtensions(owner, extensions, databaseForTable, ownDatabase, allowExtend, issues) {
+  for (const extension of extensions) {
+    const database = databaseForTable(extension.table) ?? ownDatabase;
+    const table = await describeSchemaTable(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 = isSchemaExtensionAllowed(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 \`${describeSchemaExtensionApproval(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 = getSqlColumnType(field, database.dialect);
+      const mine = columnTypeFamily(expected);
+      const theirs = columnTypeFamily(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()}.`
+        });
+      }
+    }
+  }
+}
+__name(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] : [],
+      ...owner.dependsOn?.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");
+}
+__name(formatSchemaCheck, "formatSchemaCheck");
+
+export {
+  collectSchemaDependencies,
+  orderSchemaOwners,
+  collectSchemaOwners,
+  checkSchema,
+  formatSchemaCheck
+};