@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-JVXW76I7.mjs

@@ -1,727 +0,0 @@
-import {
-  resolveIntegrationOrmRuntimeClient
-} from "./chunk-S6ENKNNG.mjs";
-import {
-  collectSchemaModels,
-  columnTypeFamily,
-  createSchemaExecutor,
-  createSchemaSnapshot,
-  describeForeignKeyApproval,
-  describeSchemaTable,
-  diffSchemaSnapshots,
-  findSchemaTableOwners,
-  getSqlColumnType,
-  hasSchemaChanges,
-  planCrossOwnerReferences,
-  planOwnerSchemaSteps,
-  planSchemaMigration,
-  readSchemaState,
-  withoutRenameTargets
-} from "./chunk-T76H22WI.mjs";
-import {
-  collectSchemaExtensions,
-  describeSchemaExtensionApproval,
-  isSchemaExtensionAllowed,
-  readSchemaTables
-} from "./chunk-GC3EM6H4.mjs";
-import {
-  resolveSchemaModels
-} from "./chunk-WDMIW6Q6.mjs";
-import {
-  getIntegrationSchemas
-} from "./chunk-37VKVISD.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
-};