nextly 0.0.1 → 0.0.2-alpha.0

package/dist/chunk-SBACDPNX.mjs

@@ -0,0 +1,689 @@
+import {
+  getColumnDescriptor,
+  getSystemColumnDescriptors
+} from "./chunk-DNNG377Z.mjs";
+
+// src/domains/schema/pipeline/classifier/count-helpers.ts
+import { sql } from "drizzle-orm";
+var SAFE_IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function quoteIdent(name, dialect) {
+  if (!SAFE_IDENT.test(name)) {
+    throw new Error(
+      `unsafe identifier: ${name} (only [A-Za-z_][A-Za-z0-9_]* allowed)`
+    );
+  }
+  return dialect === "mysql" ? `\`${name}\`` : `"${name}"`;
+}
+function asNumber(raw) {
+  if (raw === void 0) return 0;
+  return typeof raw === "string" ? parseInt(raw, 10) : raw;
+}
+function extractCount(raw, dialect) {
+  if (dialect === "postgresql") {
+    const rows = raw.rows;
+    if (!Array.isArray(rows) || rows.length === 0) {
+      throw new Error("PG count query returned no rows");
+    }
+    return asNumber(rows[0].count);
+  }
+  if (dialect === "mysql") {
+    if (Array.isArray(raw) && raw.length > 0 && Array.isArray(raw[0])) {
+      const rows = raw[0];
+      if (rows.length === 0)
+        throw new Error("MySQL count query returned no rows");
+      return asNumber(rows[0].count);
+    }
+    if (Array.isArray(raw)) {
+      const rows = raw;
+      if (rows.length === 0)
+        throw new Error("MySQL count query returned no rows");
+      return asNumber(rows[0].count);
+    }
+    throw new Error("MySQL count query returned unrecognized shape");
+  }
+  throw new Error(`unrecognized dialect for extractCount: ${dialect}`);
+}
+async function countNulls(db, dialect, table, column) {
+  const tbl = quoteIdent(table, dialect);
+  const col = quoteIdent(column, dialect);
+  const query = sql.raw(
+    `SELECT COUNT(*) AS count FROM ${tbl} WHERE ${col} IS NULL`
+  );
+  if (dialect === "sqlite") {
+    const dbTyped2 = db;
+    const rows = dbTyped2.all(query);
+    if (rows.length === 0)
+      throw new Error("SQLite count query returned no rows");
+    return asNumber(rows[0].count);
+  }
+  const dbTyped = db;
+  const result = await dbTyped.execute(query);
+  return extractCount(result, dialect);
+}
+async function countRows(db, dialect, table) {
+  const tbl = quoteIdent(table, dialect);
+  const query = sql.raw(`SELECT COUNT(*) AS count FROM ${tbl}`);
+  if (dialect === "sqlite") {
+    const dbTyped2 = db;
+    const rows = dbTyped2.all(query);
+    if (rows.length === 0)
+      throw new Error("SQLite count query returned no rows");
+    return asNumber(rows[0].count);
+  }
+  const dbTyped = db;
+  const result = await dbTyped.execute(query);
+  return extractCount(result, dialect);
+}
+
+// src/domains/schema/pipeline/resolution/types.ts
+function formatEventId(kind, table, column) {
+  return `${kind}:${table}.${column}`;
+}
+
+// src/domains/schema/pipeline/classifier/type-warnings.ts
+function buildPerDialectWarning(fromType, toType) {
+  const change = `${fromType} -> ${toType}`;
+  return {
+    pg: `Postgres: ${change} will fail if any value cannot be cast to ${toType}. Failed apply rolls back the entire transaction.`,
+    mysql: `MySQL: ${change} silently coerces non-conforming values (numeric -> 0, invalid date -> 0000-00-00, truncated strings). No error raised.`,
+    sqlite: `SQLite: ${change} uses storage-class affinity \u2014 values that don't match the new affinity are silently coerced (e.g. text "abc" stored as "abc" in an integer column, "42" stored as 42). No error raised.`
+  };
+}
+
+// src/domains/schema/pipeline/classifier/type-widening.ts
+var VARCHAR_RE = /^varchar\((\d+)\)$/i;
+var CHAR_RE = /^char\((\d+)\)$/i;
+var PG_INT_RANK = {
+  smallint: 1,
+  int2: 1,
+  int: 2,
+  integer: 2,
+  int4: 2,
+  bigint: 3,
+  int8: 3
+};
+var MYSQL_INT_RANK = {
+  tinyint: 1,
+  smallint: 2,
+  mediumint: 3,
+  int: 4,
+  integer: 4,
+  bigint: 5
+};
+var MYSQL_TEXT_RANK = {
+  tinytext: 1,
+  text: 2,
+  mediumtext: 3,
+  longtext: 4
+};
+function widensVarchar(from, to) {
+  const fm = VARCHAR_RE.exec(from);
+  const tm = VARCHAR_RE.exec(to);
+  if (fm && tm) return parseInt(tm[1], 10) >= parseInt(fm[1], 10);
+  return null;
+}
+function isWideningChange(fromType, toType, dialect) {
+  const from = fromType.toLowerCase().trim();
+  const to = toType.toLowerCase().trim();
+  if (from === to) return true;
+  if (dialect === "sqlite") return false;
+  const vw = widensVarchar(from, to);
+  if (vw !== null) return vw;
+  const fromIsCharFamily = CHAR_RE.test(from) || from === "bpchar";
+  if (fromIsCharFamily && (to === "varchar" || VARCHAR_RE.test(to))) {
+    return true;
+  }
+  if (dialect === "postgresql" && from === "bpchar" && to === "text") {
+    return true;
+  }
+  if (dialect === "postgresql" && (from === "varchar" || VARCHAR_RE.test(from)) && to === "text") {
+    return true;
+  }
+  if (dialect === "mysql" && VARCHAR_RE.test(from) && MYSQL_TEXT_RANK[to] !== void 0) {
+    return true;
+  }
+  const intRank = dialect === "postgresql" ? PG_INT_RANK : MYSQL_INT_RANK;
+  if (intRank[from] !== void 0 && intRank[to] !== void 0) {
+    return intRank[to] >= intRank[from];
+  }
+  if (dialect === "mysql" && MYSQL_TEXT_RANK[from] !== void 0 && MYSQL_TEXT_RANK[to] !== void 0) {
+    return MYSQL_TEXT_RANK[to] >= MYSQL_TEXT_RANK[from];
+  }
+  return false;
+}
+
+// src/domains/schema/pipeline/classifier/classifier.ts
+var RealClassifier = class {
+  async classify(args) {
+    const events = [];
+    for (const op of args.operations) {
+      if (op.type === "change_column_nullable" && op.fromNullable === true && op.toNullable === false) {
+        const nullCount = await args.countNulls(op.tableName, op.columnName);
+        if (nullCount > 0) {
+          const tableRowCount = await args.countRows(op.tableName);
+          events.push({
+            id: formatEventId(
+              "add_not_null_with_nulls",
+              op.tableName,
+              op.columnName
+            ),
+            kind: "add_not_null_with_nulls",
+            tableName: op.tableName,
+            columnName: op.columnName,
+            nullCount,
+            tableRowCount,
+            applicableResolutions: [
+              "provide_default",
+              "make_optional",
+              "delete_nonconforming",
+              "abort"
+            ]
+          });
+        }
+      } else if (op.type === "change_column_type") {
+        const widening = isWideningChange(op.fromType, op.toType, args.dialect);
+        if (!widening) {
+          events.push({
+            id: formatEventId("type_change", op.tableName, op.columnName),
+            kind: "type_change",
+            tableName: op.tableName,
+            columnName: op.columnName,
+            fromType: op.fromType,
+            toType: op.toType,
+            isWidening: false,
+            perDialectWarning: buildPerDialectWarning(op.fromType, op.toType)
+          });
+        }
+      } else if (op.type === "add_column" && op.column.nullable === false && op.column.default === void 0) {
+        const tableRowCount = await args.countRows(op.tableName);
+        if (tableRowCount > 0) {
+          events.push({
+            id: formatEventId(
+              "add_required_field_no_default",
+              op.tableName,
+              op.column.name
+            ),
+            kind: "add_required_field_no_default",
+            tableName: op.tableName,
+            columnName: op.column.name,
+            tableRowCount,
+            applicableResolutions: [
+              "provide_default",
+              "make_optional",
+              "abort"
+            ]
+          });
+        }
+      }
+    }
+    const hasInteractive = events.some((e) => e.kind !== "type_change");
+    const level = hasInteractive ? "interactive" : events.length > 0 ? "destructive" : "safe";
+    return { level, events };
+  }
+};
+
+// src/domains/schema/pipeline/diff/build-from-fields.ts
+function buildDesiredTableFromFields(tableName, fields, dialect, options = {}) {
+  const columns = [];
+  const hasTitleField = fields.some((f) => f.name === "title");
+  const hasSlugField = fields.some((f) => f.name === "slug");
+  for (const reserved of getSystemColumnDescriptors(dialect, {
+    hasTitleField,
+    hasSlugField,
+    hasStatus: options.hasStatus
+  })) {
+    columns.push({
+      name: reserved.name,
+      type: reserved.dialectType,
+      nullable: reserved.nullable,
+      default: void 0
+    });
+  }
+  for (const field of fields) {
+    const desc = getColumnDescriptor(
+      // The descriptor's input type is FieldDefinition; this util is
+      // structurally compatible (same name/type/required/hasMany/relationTo
+      // keys). Cast through unknown to bridge the two surface types
+      // without leaking either back through the module graph.
+      field,
+      dialect
+    );
+    if (!desc) continue;
+    columns.push({
+      name: desc.name,
+      type: desc.dialectType,
+      nullable: desc.nullable,
+      default: void 0
+    });
+  }
+  return { name: tableName, columns };
+}
+function buildDesiredTableFromComponentFields(tableName, fields, dialect) {
+  const columns = [];
+  if (dialect === "postgresql") {
+    columns.push({ name: "id", type: "text", nullable: false, default: void 0 });
+    columns.push({ name: "_parent_id", type: "text", nullable: false, default: void 0 });
+    columns.push({ name: "_parent_table", type: "varchar", nullable: false, default: void 0 });
+    columns.push({ name: "_parent_field", type: "varchar", nullable: false, default: void 0 });
+    columns.push({ name: "_order", type: "int4", nullable: true, default: void 0 });
+    columns.push({ name: "_component_type", type: "varchar", nullable: true, default: void 0 });
+  } else if (dialect === "mysql") {
+    columns.push({ name: "id", type: "varchar(36)", nullable: false, default: void 0 });
+    columns.push({ name: "_parent_id", type: "varchar(36)", nullable: false, default: void 0 });
+    columns.push({ name: "_parent_table", type: "varchar(255)", nullable: false, default: void 0 });
+    columns.push({ name: "_parent_field", type: "varchar(255)", nullable: false, default: void 0 });
+    columns.push({ name: "_order", type: "int(11)", nullable: true, default: void 0 });
+    columns.push({ name: "_component_type", type: "varchar(255)", nullable: true, default: void 0 });
+  } else {
+    columns.push({ name: "id", type: "text", nullable: false, default: void 0 });
+    columns.push({ name: "_parent_id", type: "text", nullable: false, default: void 0 });
+    columns.push({ name: "_parent_table", type: "text", nullable: false, default: void 0 });
+    columns.push({ name: "_parent_field", type: "text", nullable: false, default: void 0 });
+    columns.push({ name: "_order", type: "integer", nullable: true, default: void 0 });
+    columns.push({ name: "_component_type", type: "text", nullable: true, default: void 0 });
+  }
+  for (const field of fields) {
+    const desc = getColumnDescriptor(
+      field,
+      dialect
+    );
+    if (!desc) continue;
+    columns.push({
+      name: desc.name,
+      type: desc.dialectType,
+      nullable: desc.nullable,
+      default: void 0
+    });
+  }
+  if (dialect === "postgresql") {
+    columns.push({ name: "created_at", type: "timestamp", nullable: false, default: void 0 });
+    columns.push({ name: "updated_at", type: "timestamp", nullable: false, default: void 0 });
+  } else if (dialect === "mysql") {
+    columns.push({ name: "created_at", type: "datetime", nullable: false, default: void 0 });
+    columns.push({ name: "updated_at", type: "datetime", nullable: false, default: void 0 });
+  } else {
+    columns.push({ name: "created_at", type: "integer", nullable: false, default: void 0 });
+    columns.push({ name: "updated_at", type: "integer", nullable: false, default: void 0 });
+  }
+  return { name: tableName, columns };
+}
+
+// src/domains/schema/pipeline/diff/diff.ts
+function diffSnapshots(prev, cur) {
+  const prevByName = /* @__PURE__ */ new Map();
+  for (const t of prev.tables) prevByName.set(t.name, t);
+  const curByName = /* @__PURE__ */ new Map();
+  for (const t of cur.tables) curByName.set(t.name, t);
+  const tableOps = [];
+  const columnOps = [];
+  const allTableNames = [
+    .../* @__PURE__ */ new Set([...prevByName.keys(), ...curByName.keys()])
+  ].sort();
+  for (const name of allTableNames) {
+    const prevT = prevByName.get(name);
+    const curT = curByName.get(name);
+    if (!prevT && curT) {
+      tableOps.push({ type: "add_table", table: curT });
+      continue;
+    }
+    if (prevT && !curT) {
+      tableOps.push({
+        type: "drop_table",
+        tableName: name
+      });
+      continue;
+    }
+    if (prevT && curT) {
+      columnOps.push(...diffColumns(name, prevT.columns, curT.columns));
+    }
+  }
+  return [...tableOps, ...columnOps];
+}
+function diffColumns(tableName, prev, cur) {
+  const prevByName = /* @__PURE__ */ new Map();
+  for (const c of prev) prevByName.set(c.name, c);
+  const curByName = /* @__PURE__ */ new Map();
+  for (const c of cur) curByName.set(c.name, c);
+  const drops = [];
+  const adds = [];
+  const typeChanges = [];
+  const nullableChanges = [];
+  const defaultChanges = [];
+  const allColumnNames = [
+    .../* @__PURE__ */ new Set([...prevByName.keys(), ...curByName.keys()])
+  ].sort();
+  for (const name of allColumnNames) {
+    const prevC = prevByName.get(name);
+    const curC = curByName.get(name);
+    if (!prevC && curC) {
+      adds.push({ type: "add_column", tableName, column: curC });
+      continue;
+    }
+    if (prevC && !curC) {
+      drops.push({
+        type: "drop_column",
+        tableName,
+        columnName: name,
+        columnType: prevC.type
+      });
+      continue;
+    }
+    if (prevC && curC) {
+      if (prevC.type !== curC.type) {
+        typeChanges.push({
+          type: "change_column_type",
+          tableName,
+          columnName: name,
+          fromType: prevC.type,
+          toType: curC.type
+        });
+      }
+      if (prevC.nullable !== curC.nullable) {
+        nullableChanges.push({
+          type: "change_column_nullable",
+          tableName,
+          columnName: name,
+          fromNullable: prevC.nullable,
+          toNullable: curC.nullable
+        });
+      }
+      if (prevC.default !== curC.default) {
+        defaultChanges.push({
+          type: "change_column_default",
+          tableName,
+          columnName: name,
+          fromDefault: prevC.default,
+          toDefault: curC.default
+        });
+      }
+    }
+  }
+  return [
+    ...drops,
+    ...adds,
+    ...typeChanges,
+    ...nullableChanges,
+    ...defaultChanges
+  ];
+}
+
+// src/domains/schema/pipeline/diff/introspect-live.ts
+import { sql as sql2 } from "drizzle-orm";
+async function introspectLiveSnapshot(db, dialect, tableNames) {
+  if (tableNames.length === 0) return { tables: [] };
+  const tableNamesIn = sql2.join(
+    tableNames.map((t) => sql2`${t}`),
+    sql2`, `
+  );
+  if (dialect === "postgresql") {
+    const dbTyped2 = db;
+    const result = await dbTyped2.execute(
+      sql2`SELECT table_name, column_name, udt_name, is_nullable, column_default
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+            AND table_name IN (${tableNamesIn})
+          ORDER BY table_name, ordinal_position`
+    );
+    return buildSnapshotFromPgRows(result.rows);
+  }
+  if (dialect === "mysql") {
+    const dbTyped2 = db;
+    const result = await dbTyped2.execute(
+      sql2`SELECT TABLE_NAME, COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_DEFAULT
+          FROM information_schema.columns
+          WHERE TABLE_SCHEMA = DATABASE()
+            AND TABLE_NAME IN (${tableNamesIn})
+          ORDER BY TABLE_NAME, ORDINAL_POSITION`
+    );
+    const rows = Array.isArray(result) && result.length > 0 && Array.isArray(result[0]) ? result[0] : result;
+    return buildSnapshotFromMysqlRows(rows);
+  }
+  const dbTyped = db;
+  const tables = [];
+  for (const table of tableNames) {
+    const rows = await dbTyped.all(
+      sql2`PRAGMA table_info(${sql2.identifier(table)})`
+    );
+    if (rows.length === 0) continue;
+    tables.push({
+      name: table,
+      columns: rows.map(
+        (r) => ({
+          name: r.name,
+          // SQLite's PRAGMA table_info auto-uppercases the type name
+          // ("text" becomes "TEXT"), even though Drizzle emits lowercase
+          // declarations in CREATE TABLE. The
+          // `field-column-descriptor` (the desired-side source of
+          // truth) renders lowercase tokens to match drizzle-orm's
+          // own introspection convention. Without this lowercase
+          // pass, every boot/HMR diff sees fake `TEXT -> text`
+          // type-change events on every column and classifies the
+          // collection as "needs review", which silently blocks
+          // legitimate code-first applies (rename, add, drop) from
+          // ever running. Lowercasing here is safe because SQLite
+          // type names are case-insensitive at the engine level.
+          type: r.type.toLowerCase(),
+          // SQLite stores notnull as 0/1 integer.
+          nullable: r.notnull === 0,
+          // dflt_value can be string, number, null, or undefined.
+          // Coerce primitives to string; treat anything non-primitive as
+          // missing (defensive - SQLite never returns object defaults).
+          default: stringifyDefault(r.dflt_value)
+        })
+      )
+    });
+  }
+  return { tables };
+}
+function stringifyDefault(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return value.toString();
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "bigint") return value.toString();
+  return void 0;
+}
+function buildSnapshotFromPgRows(rows) {
+  const byTable = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    let cols = byTable.get(r.table_name);
+    if (!cols) {
+      cols = [];
+      byTable.set(r.table_name, cols);
+    }
+    cols.push({
+      name: r.column_name,
+      type: r.udt_name,
+      nullable: r.is_nullable === "YES",
+      default: r.column_default ?? void 0
+    });
+  }
+  return {
+    tables: [...byTable.entries()].map(
+      ([name, columns]) => ({ name, columns })
+    )
+  };
+}
+function buildSnapshotFromMysqlRows(rows) {
+  const byTable = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    let cols = byTable.get(r.TABLE_NAME);
+    if (!cols) {
+      cols = [];
+      byTable.set(r.TABLE_NAME, cols);
+    }
+    cols.push({
+      name: r.COLUMN_NAME,
+      type: r.COLUMN_TYPE,
+      nullable: r.IS_NULLABLE === "YES",
+      default: r.COLUMN_DEFAULT ?? void 0
+    });
+  }
+  return {
+    tables: [...byTable.entries()].map(
+      ([name, columns]) => ({ name, columns })
+    )
+  };
+}
+
+// src/domains/schema/pipeline/rename-detector-type-families.ts
+var PG_FAMILIES = {
+  // bpchar is what PG's information_schema.columns.udt_name returns for
+  // char(N) columns (blank-padded char). Without it here, a legitimate
+  // char(N) -> text rename would default to drop_and_add.
+  text: ["text", "varchar", "char", "bpchar", "character", "character varying"],
+  integer: [
+    "smallint",
+    "integer",
+    "int",
+    "int2",
+    "int4",
+    "int8",
+    "bigint",
+    "serial",
+    "bigserial",
+    "smallserial"
+  ],
+  decimal: [
+    "decimal",
+    "numeric",
+    "real",
+    "double precision",
+    "double",
+    "float"
+  ],
+  boolean: ["boolean", "bool"],
+  uuid: ["uuid"],
+  json: ["json", "jsonb"],
+  date_only: ["date"],
+  time_only: [
+    "time",
+    "timetz",
+    "time with time zone",
+    "time without time zone"
+  ],
+  timestamp: [
+    "timestamp",
+    "timestamptz",
+    "timestamp with time zone",
+    "timestamp without time zone"
+  ],
+  binary: ["bytea"]
+};
+var MYSQL_FAMILIES = {
+  text: ["text", "varchar", "char", "tinytext", "mediumtext", "longtext"],
+  integer: ["tinyint", "smallint", "mediumint", "int", "integer", "bigint"],
+  decimal: ["decimal", "numeric", "float", "double", "real"],
+  boolean: ["boolean", "bool"],
+  uuid: [],
+  json: ["json"],
+  date_only: ["date"],
+  time_only: ["time"],
+  timestamp: ["timestamp", "datetime"],
+  binary: ["binary", "varbinary", "tinyblob", "blob", "mediumblob", "longblob"]
+};
+var SQLITE_FAMILIES = {
+  text: ["text", "varchar", "char", "character"],
+  integer: ["integer", "int", "tinyint", "smallint", "mediumint", "bigint"],
+  decimal: ["real", "double", "decimal", "numeric", "float"],
+  boolean: ["boolean", "bool"],
+  uuid: [],
+  json: [],
+  date_only: [],
+  time_only: [],
+  timestamp: [],
+  binary: ["blob"]
+};
+var FAMILY_TABLES = {
+  postgresql: PG_FAMILIES,
+  mysql: MYSQL_FAMILIES,
+  sqlite: SQLITE_FAMILIES
+};
+function leadingToken(rawType) {
+  const trimmed = rawType.trim().toLowerCase();
+  if (trimmed.length === 0) return null;
+  const parenIdx = trimmed.indexOf("(");
+  const modifierMatch = trimmed.match(
+    /\s(?:not|null|default|references|primary|unique|collate|check)\b/
+  );
+  const modifierIdx = modifierMatch?.index ?? -1;
+  let endIdx = trimmed.length;
+  if (parenIdx >= 0) endIdx = Math.min(endIdx, parenIdx);
+  if (modifierIdx >= 0) endIdx = Math.min(endIdx, modifierIdx);
+  return trimmed.slice(0, endIdx).trim();
+}
+function typeFamilyOf(rawType, dialect) {
+  const token = leadingToken(rawType);
+  if (!token) return null;
+  const table = FAMILY_TABLES[dialect];
+  for (const family of Object.keys(table)) {
+    if (table[family].includes(token)) return family;
+  }
+  return null;
+}
+function isTypesCompatible(fromType, toType, dialect) {
+  const fromFamily = typeFamilyOf(fromType, dialect);
+  const toFamily = typeFamilyOf(toType, dialect);
+  if (fromFamily === null || toFamily === null) return false;
+  return fromFamily === toFamily;
+}
+
+// src/domains/schema/pipeline/rename-detector.ts
+var RegexRenameDetector = class {
+  detect(operations, dialect) {
+    const dropsByTable = /* @__PURE__ */ new Map();
+    const addsByTable = /* @__PURE__ */ new Map();
+    for (const op of operations) {
+      if (op.type === "drop_column") {
+        const list = dropsByTable.get(op.tableName) ?? [];
+        list.push(op);
+        dropsByTable.set(op.tableName, list);
+      } else if (op.type === "add_column") {
+        const list = addsByTable.get(op.tableName) ?? [];
+        list.push(op);
+        addsByTable.set(op.tableName, list);
+      }
+    }
+    const candidates = [];
+    for (const [tableName, drops] of dropsByTable) {
+      const adds = addsByTable.get(tableName);
+      if (!adds || adds.length === 0) continue;
+      for (const drop of drops) {
+        for (const add of adds) {
+          const fromType = drop.columnType;
+          const toType = add.column.type;
+          const compatible = fromType === "" ? false : isTypesCompatible(fromType, toType, dialect);
+          candidates.push({
+            tableName,
+            fromColumn: drop.columnName,
+            toColumn: add.column.name,
+            fromType,
+            toType,
+            typesCompatible: compatible,
+            defaultSuggestion: compatible ? "rename" : "drop_and_add"
+          });
+        }
+      }
+    }
+    candidates.sort((a, b) => {
+      if (a.tableName !== b.tableName)
+        return a.tableName < b.tableName ? -1 : 1;
+      if (a.fromColumn !== b.fromColumn)
+        return a.fromColumn < b.fromColumn ? -1 : 1;
+      if (a.toColumn !== b.toColumn) return a.toColumn < b.toColumn ? -1 : 1;
+      return 0;
+    });
+    return candidates;
+  }
+};
+
+export {
+  countNulls,
+  countRows,
+  RealClassifier,
+  buildDesiredTableFromFields,
+  buildDesiredTableFromComponentFields,
+  diffSnapshots,
+  introspectLiveSnapshot,
+  RegexRenameDetector
+};