@hot-updater/server 0.33.2 → 0.35.0

package/src/db/schema/sqlMigrations.ts

@@ -0,0 +1,219 @@
+import { hotUpdaterSchemaVersions } from "../../schema";
+import type {
+  HotUpdaterCheckSchema,
+  HotUpdaterForeignKeySchema,
+  HotUpdaterTableSchema,
+} from "../../schema/types";
+import type { ORMSQLProvider, RelationMode } from "../types";
+import {
+  getSchemaVersionIndex,
+  schemaIndexAppliesToProvider,
+} from "./registry";
+import {
+  createIndexSql,
+  createTableStatement,
+  sqlColumnDefinition,
+} from "./sql";
+
+const nameMap = <T extends { readonly name: string }>(
+  items: readonly T[] | undefined,
+): Map<string, T> => new Map((items ?? []).map((item) => [item.name, item]));
+
+const columnMap = (
+  table: HotUpdaterTableSchema,
+): Map<string, { readonly ormName: string }> =>
+  new Map(table.columns.map((column) => [column.ormName, column]));
+
+const stableStringify = (value: unknown): string => JSON.stringify(value);
+
+const assertSameSchemaValue = (
+  location: string,
+  left: unknown,
+  right: unknown,
+) => {
+  if (stableStringify(left) !== stableStringify(right)) {
+    throw new Error(
+      `Unsupported Hot Updater schema change at ${location}. Add an explicit migration step before changing existing schema metadata.`,
+    );
+  }
+};
+
+const compareNamedItems = <T extends { readonly name: string }>(
+  location: string,
+  previousItems: readonly T[] | undefined,
+  nextItems: readonly T[] | undefined,
+) => {
+  const nextItemsByName = nameMap(nextItems);
+  for (const previousItem of previousItems ?? []) {
+    const nextItem = nextItemsByName.get(previousItem.name);
+    if (!nextItem) {
+      throw new Error(
+        `Unsupported Hot Updater schema change at ${location}.${previousItem.name}. Removing schema metadata requires an explicit migration step.`,
+      );
+    }
+    assertSameSchemaValue(
+      `${location}.${previousItem.name}`,
+      previousItem,
+      nextItem,
+    );
+  }
+};
+
+const assertNoUnsupportedTableChanges = (
+  previous: HotUpdaterTableSchema,
+  next: HotUpdaterTableSchema,
+  provider: ORMSQLProvider,
+) => {
+  const nextColumns = columnMap(next);
+  for (const previousColumn of previous.columns) {
+    const nextColumn = nextColumns.get(previousColumn.ormName);
+    if (!nextColumn) {
+      throw new Error(
+        `Unsupported Hot Updater schema change at ${previous.ormName}.${previousColumn.ormName}. Dropping columns requires an explicit migration step.`,
+      );
+    }
+    assertSameSchemaValue(
+      `${previous.ormName}.${previousColumn.ormName}`,
+      previousColumn,
+      nextColumn,
+    );
+  }
+  compareNamedItems(
+    `${previous.ormName}.indexes`,
+    previous.indexes?.filter((index) =>
+      schemaIndexAppliesToProvider(index, provider),
+    ),
+    next.indexes?.filter((index) =>
+      schemaIndexAppliesToProvider(index, provider),
+    ),
+  );
+  compareNamedItems(`${previous.ormName}.checks`, previous.checks, next.checks);
+  compareNamedItems(
+    `${previous.ormName}.foreignKeys`,
+    previous.foreignKeys,
+    next.foreignKeys,
+  );
+};
+
+const createForeignKeySql = (
+  table: HotUpdaterTableSchema,
+  foreignKey: HotUpdaterForeignKeySchema,
+): string =>
+  `alter table ${table.ormName} add constraint ${foreignKey.name} foreign key (${foreignKey.columns.join(", ")}) references ${foreignKey.referencedTable}(${foreignKey.referencedColumns.join(", ")}) on update ${foreignKey.onUpdate} on delete ${foreignKey.onDelete}`;
+
+const createCheckSql = (
+  table: HotUpdaterTableSchema,
+  check: HotUpdaterCheckSchema,
+): string =>
+  `alter table ${table.ormName} add constraint ${check.name} check (${check.expression})`;
+
+const createAddedTableSql = (
+  table: HotUpdaterTableSchema,
+  provider: ORMSQLProvider,
+  relationMode: RelationMode,
+): readonly string[] => [
+  createTableStatement(table, provider),
+  ...(table.indexes ?? [])
+    .filter((index) => schemaIndexAppliesToProvider(index, provider))
+    .map((index) => createIndexSql(table, index, provider)),
+  ...(provider === "sqlite"
+    ? []
+    : (table.checks ?? []).map((check) => createCheckSql(table, check))),
+  ...(relationMode === "foreign-keys" && provider !== "sqlite"
+    ? (table.foreignKeys ?? []).map((foreignKey) =>
+        createForeignKeySql(table, foreignKey),
+      )
+    : []),
+];
+
+const createChangedTableSql = (
+  previous: HotUpdaterTableSchema,
+  next: HotUpdaterTableSchema,
+  provider: ORMSQLProvider,
+  relationMode: RelationMode,
+): readonly string[] => {
+  assertNoUnsupportedTableChanges(previous, next, provider);
+  const previousColumns = columnMap(previous);
+  const previousIndexes = nameMap(
+    previous.indexes?.filter((index) =>
+      schemaIndexAppliesToProvider(index, provider),
+    ),
+  );
+  const previousChecks = nameMap(previous.checks);
+  const previousForeignKeys = nameMap(previous.foreignKeys);
+
+  return [
+    ...next.columns
+      .filter((column) => !previousColumns.has(column.ormName))
+      .map(
+        (column) =>
+          `alter table ${next.ormName} add column ${sqlColumnDefinition(
+            next,
+            column,
+            provider,
+          )}`,
+      ),
+    ...(next.indexes ?? [])
+      .filter((index) => schemaIndexAppliesToProvider(index, provider))
+      .filter((index) => !previousIndexes.has(index.name))
+      .map((index) => createIndexSql(next, index, provider)),
+    ...(provider === "sqlite"
+      ? []
+      : (next.checks ?? [])
+          .filter((check) => !previousChecks.has(check.name))
+          .map((check) => createCheckSql(next, check))),
+    ...(relationMode === "foreign-keys" && provider !== "sqlite"
+      ? (next.foreignKeys ?? [])
+          .filter((foreignKey) => !previousForeignKeys.has(foreignKey.name))
+          .map((foreignKey) => createForeignKeySql(next, foreignKey))
+      : []),
+  ];
+};
+
+export const createSchemaMigrationSql = (
+  fromVersion: string,
+  toVersion: string,
+  provider: ORMSQLProvider,
+  relationMode: RelationMode = "foreign-keys",
+): readonly string[] => {
+  const fromIndex = getSchemaVersionIndex(fromVersion);
+  const toIndex = getSchemaVersionIndex(toVersion);
+  if (fromIndex === -1) {
+    throw new Error(`Unsupported Hot Updater schema version: ${fromVersion}`);
+  }
+  if (toIndex === -1) {
+    throw new Error(`Unsupported Hot Updater schema version: ${toVersion}`);
+  }
+  if (fromIndex > toIndex) {
+    throw new Error(`Cannot migrate Hot Updater schema down to ${toVersion}.`);
+  }
+
+  const statements: string[] = [];
+  for (let index = fromIndex + 1; index <= toIndex; index += 1) {
+    const previous = hotUpdaterSchemaVersions[index - 1]!;
+    const next = hotUpdaterSchemaVersions[index]!;
+    const previousTables = new Map(
+      previous.tables.map((table) => [table.ormName, table]),
+    );
+    for (const table of next.tables) {
+      if (table.internal) continue;
+      const previousTable = previousTables.get(table.ormName);
+      statements.push(
+        ...(previousTable
+          ? createChangedTableSql(previousTable, table, provider, relationMode)
+          : createAddedTableSql(table, provider, relationMode)),
+      );
+    }
+  }
+  return statements;
+};
+
+export const createV029AlterSql = (
+  provider: ORMSQLProvider,
+): readonly string[] => createSchemaMigrationSql("0.21.0", "0.29.0", provider);
+
+export const createV031AlterSql = (
+  provider: ORMSQLProvider,
+  relationMode: RelationMode = "foreign-keys",
+): readonly string[] =>
+  createSchemaMigrationSql("0.29.0", "0.31.0", provider, relationMode);

package/src/db/schema/sqlOperations.ts

@@ -0,0 +1,62 @@
+import {
+  HOT_UPDATER_SCHEMA_VERSION,
+  HOT_UPDATER_SETTINGS_TABLE,
+} from "../../schema/types";
+import type {
+  MigrationOperation,
+  ORMSQLProvider,
+  RelationMode,
+} from "../types";
+import { hotUpdaterSchema, schemaIndexAppliesToProvider } from "./registry";
+import {
+  createCheckSql,
+  createForeignKeySql,
+  createIndexSql,
+  hotUpdaterCreateTableOperations,
+} from "./sql";
+
+export const getSettingsInsertSql = (provider: ORMSQLProvider) => {
+  if (provider === "mysql") {
+    return `insert into ${HOT_UPDATER_SETTINGS_TABLE} (\`key\`, value) values ('version', '${HOT_UPDATER_SCHEMA_VERSION}') on duplicate key update value = '${HOT_UPDATER_SCHEMA_VERSION}'`;
+  }
+  return `insert into ${HOT_UPDATER_SETTINGS_TABLE} (key, value) values ('version', '${HOT_UPDATER_SCHEMA_VERSION}') on conflict (key) do update set value = '${HOT_UPDATER_SCHEMA_VERSION}'`;
+};
+
+export const createSqlCreateOperations = (
+  provider: ORMSQLProvider,
+  relationMode: RelationMode,
+  settingsOperation?: MigrationOperation,
+): MigrationOperation[] => [
+  ...hotUpdaterCreateTableOperations,
+  ...hotUpdaterSchema.tables.flatMap((table) =>
+    (table.indexes ?? [])
+      .filter((index) => schemaIndexAppliesToProvider(index, provider))
+      .map(
+        (index): MigrationOperation => ({
+          type: "custom",
+          sql: createIndexSql(table, index, provider),
+        }),
+      ),
+  ),
+  ...(provider === "sqlite"
+    ? []
+    : hotUpdaterSchema.tables.flatMap((table) =>
+        (table.checks ?? []).map(
+          (check): MigrationOperation => ({
+            type: "custom",
+            sql: createCheckSql(table, check),
+          }),
+        ),
+      )),
+  ...(relationMode === "foreign-keys" && provider !== "sqlite"
+    ? hotUpdaterSchema.tables.flatMap((table) =>
+        (table.foreignKeys ?? []).map(
+          (foreignKey): MigrationOperation => ({
+            type: "custom",
+            sql: createForeignKeySql(table, foreignKey),
+          }),
+        ),
+      )
+    : []),
+  ...(settingsOperation ? [settingsOperation] : []),
+];

package/src/db/schema/types.ts

@@ -0,0 +1 @@
+export * from "../../schema/types";

package/src/db/schemaEnhancements.ts

@@ -4,35 +4,6 @@ import {
   isValidCohort,
   type Bundle,
 } from "@hot-updater/core";
-import semver from "semver";
-
-import type { ORMProvider, ORMSQLProvider } from "./types";
-
-type AdapterName = "drizzle" | "prisma" | string;
-
-type MigrationResultLike = {
-  execute: () => Promise<void>;
-  getSQL?: () => string;
-  operations: Array<Record<string, unknown>>;
-};
-
-type SchemaVersionLike = {
-  version: string;
-};
-
-type MigratorLike = {
-  down: (options?: undefined) => Promise<MigrationResultLike>;
-  getNameVariants: () => Promise<unknown>;
-  getVersion: () => Promise<string | undefined>;
-  migrateTo: (
-    version: string,
-    options?: undefined,
-  ) => Promise<MigrationResultLike>;
-  migrateToLatest: (options?: undefined) => Promise<MigrationResultLike>;
-  next: () => Promise<SchemaVersionLike | undefined>;
-  previous: () => Promise<SchemaVersionLike | undefined>;
-  up: (options?: undefined) => Promise<MigrationResultLike>;
-};
 
 const normalizeNullableString = (value: string | null | undefined) => {
   if (value === null || value === undefined) {
@@ -43,277 +14,6 @@ const normalizeNullableString = (value: string | null | undefined) => {
   return normalized.length > 0 ? normalized : null;
 };
 
-const appendPrismaModelLines = (
-  code: string,
-  modelName: string,
-  lines: string[],
-  options?: {
-    position?: "beforeAttributes" | "end";
-  },
-) => {
-  const pattern = new RegExp(
-    `model ${modelName} \\{\\n([\\s\\S]*?)\\n\\}`,
-    "m",
-  );
-  return code.replace(pattern, (full, body: string) => {
-    const bodyLines = body.split("\n");
-    const existingLines = new Set(
-      bodyLines.map((line) => line.trim()).filter(Boolean),
-    );
-    const additions = lines
-      .filter((line) => !existingLines.has(line))
-      .map((line) => `  ${line}`);
-
-    if (additions.length === 0) {
-      return full;
-    }
-
-    if (options?.position === "beforeAttributes") {
-      const insertIndex = bodyLines.findIndex((line) =>
-        line.trim().startsWith("@@"),
-      );
-      if (insertIndex === -1) {
-        bodyLines.push(...additions);
-      } else {
-        bodyLines.splice(insertIndex, 0, ...additions);
-      }
-
-      return `model ${modelName} {\n${bodyLines.join("\n")}\n}`;
-    }
-
-    return `model ${modelName} {\n${body}\n${additions.join("\n")}\n}`;
-  });
-};
-
-const getPrismaDatasourceProvider = (code: string): ORMProvider | null => {
-  const match = code.match(
-    /datasource\s+\w+\s+\{[\s\S]*?provider\s*=\s*"([^"]+)"[\s\S]*?\}/m,
-  );
-  return (match?.[1] as ORMProvider | undefined) ?? null;
-};
-
-const ensureDrizzleIndexImport = (code: string) =>
-  code.replace(
-    /import \{ ([^}]+) \} from "(drizzle-orm\/[^"]+-core)"/,
-    (_full, imports: string, modulePath: string) => {
-      const values = imports
-        .split(",")
-        .map((value) => value.trim())
-        .filter(Boolean);
-
-      if (!values.includes("index")) {
-        values.push("index");
-      }
-
-      return `import { ${values.join(", ")} } from "${modulePath}"`;
-    },
-  );
-
-const ensureDrizzleMetadataDefault = (code: string) =>
-  code
-    .replace(
-      /metadata: json\("metadata"\)\.notNull\(\)(?!\.default\(\{\}\))/,
-      'metadata: json("metadata").notNull().default({})',
-    )
-    .replace(
-      /metadata: blob\("metadata", \{ mode: "json" \}\)\.notNull\(\)(?!\.default\(\{\}\))/,
-      'metadata: blob("metadata", { mode: "json" }).notNull().default({})',
-    );
-
-const removeUnusedDrizzleRelationMany = (code: string) =>
-  code.replace(
-    /export const bundle_patchesRelations = relations\(bundle_patches, \(\{ one, many \}\) => \(\{/,
-    "export const bundle_patchesRelations = relations(bundle_patches, ({ one }) => ({",
-  );
-
-const ensureTrailingComma = (line: string) => {
-  const trimmed = line.trim();
-  if (!trimmed || trimmed.endsWith(",") || trimmed.endsWith("[")) {
-    return line;
-  }
-
-  return `${line},`;
-};
-
-const updateDrizzleTableBlock = (
-  code: string,
-  tableName: string,
-  callbackLines: string[],
-) => {
-  const blockStart = code.indexOf(`export const ${tableName} = `);
-  if (blockStart === -1) {
-    return code;
-  }
-
-  const nextBlockStart = code.indexOf("\n\nexport const ", blockStart + 1);
-  const blockEnd = nextBlockStart === -1 ? code.length : nextBlockStart;
-  const block = code.slice(blockStart, blockEnd);
-
-  if (block.includes(", (table) => [")) {
-    const callbackPattern = /, \(table\) => \[\n([\s\S]*?)\n\]\)\s*$/;
-    const match = block.match(callbackPattern);
-
-    if (!match) {
-      return code;
-    }
-
-    const callbackBody = match[1] ?? "";
-    const existingLines = callbackBody
-      .split("\n")
-      .map((line) => line.trim())
-      .filter(Boolean);
-    const additions = callbackLines.filter(
-      (line) => !existingLines.includes(line),
-    );
-
-    if (additions.length === 0) {
-      return code;
-    }
-
-    const callbackBodyLines = callbackBody.split("\n");
-    for (let index = callbackBodyLines.length - 1; index >= 0; index -= 1) {
-      if (callbackBodyLines[index]?.trim()) {
-        callbackBodyLines[index] = ensureTrailingComma(
-          callbackBodyLines[index]!,
-        );
-        break;
-      }
-    }
-
-    const nextCallbackBody = [
-      ...callbackBodyLines,
-      ...additions.map((line) => `  ${line}`),
-    ].join("\n");
-    const nextBlock = block.replace(
-      callbackPattern,
-      `, (table) => [\n${nextCallbackBody}\n])`,
-    );
-
-    return `${code.slice(0, blockStart)}${nextBlock}${code.slice(blockEnd)}`;
-  }
-
-  const callbackBody = callbackLines.map((line) => `  ${line}`).join("\n");
-  const nextBlock = block.replace(
-    /\n\}\)\s*$/,
-    `\n}, (table) => [\n${callbackBody}\n])`,
-  );
-
-  return `${code.slice(0, blockStart)}${nextBlock}${code.slice(blockEnd)}`;
-};
-
-const addCustomSqlOperation = (
-  result: MigrationResultLike,
-  sql: string,
-): void => {
-  const normalizedSql = sql.trim();
-  const alreadyAdded = result.operations.some((operation) => {
-    return (
-      operation["type"] === "custom" &&
-      typeof operation["sql"] === "string" &&
-      operation["sql"].trim() === normalizedSql
-    );
-  });
-
-  if (!alreadyAdded) {
-    result.operations.push({
-      type: "custom",
-      sql: normalizedSql,
-    });
-  }
-};
-
-const getMigrationCustomSql = (
-  provider: ORMSQLProvider,
-  targetVersion: string,
-): string[] => {
-  const statements: string[] = [];
-  const hasRolloutColumns = semver.gte(targetVersion, "0.29.0");
-  const hasPatchTable = semver.gte(targetVersion, "0.31.0");
-
-  if (provider === "postgresql") {
-    statements.push(
-      "create index bundles_target_app_version_idx on bundles(target_app_version)",
-      "create index bundles_fingerprint_hash_idx on bundles(fingerprint_hash)",
-      "create index bundles_channel_idx on bundles(channel)",
-      "alter table bundles add constraint check_version_or_fingerprint check ((target_app_version is not null) or (fingerprint_hash is not null))",
-    );
-
-    if (hasRolloutColumns) {
-      statements.push(
-        "create index bundles_rollout_idx on bundles(rollout_cohort_count)",
-        "alter table bundles add constraint bundles_rollout_cohort_count_check check (rollout_cohort_count >= 0 and rollout_cohort_count <= 1000)",
-      );
-    }
-
-    if (hasPatchTable) {
-      statements.push(
-        "create index bundle_patches_bundle_id_idx on bundle_patches(bundle_id)",
-        "create index bundle_patches_base_bundle_id_idx on bundle_patches(base_bundle_id)",
-      );
-    }
-
-    return statements;
-  }
-
-  if (provider === "mysql") {
-    statements.push(
-      "create index bundles_target_app_version_idx on bundles(target_app_version(255))",
-      "create index bundles_fingerprint_hash_idx on bundles(fingerprint_hash(255))",
-      "create index bundles_channel_idx on bundles(channel(255))",
-      "alter table bundles add constraint check_version_or_fingerprint check ((target_app_version is not null) or (fingerprint_hash is not null))",
-    );
-
-    if (hasRolloutColumns) {
-      statements.push(
-        "create index bundles_rollout_idx on bundles(rollout_cohort_count)",
-        "alter table bundles add constraint bundles_rollout_cohort_count_check check (rollout_cohort_count >= 0 and rollout_cohort_count <= 1000)",
-      );
-    }
-
-    if (hasPatchTable) {
-      statements.push(
-        "create index bundle_patches_bundle_id_idx on bundle_patches(bundle_id)",
-        "create index bundle_patches_base_bundle_id_idx on bundle_patches(base_bundle_id)",
-      );
-    }
-
-    return statements;
-  }
-
-  statements.push(
-    "create index bundles_target_app_version_idx on bundles(target_app_version)",
-    "create index bundles_fingerprint_hash_idx on bundles(fingerprint_hash)",
-    "create index bundles_channel_idx on bundles(channel)",
-  );
-
-  if (hasRolloutColumns) {
-    statements.push(
-      "create index bundles_rollout_idx on bundles(rollout_cohort_count)",
-    );
-  }
-
-  if (hasPatchTable) {
-    statements.push(
-      "create index bundle_patches_bundle_id_idx on bundle_patches(bundle_id)",
-      "create index bundle_patches_base_bundle_id_idx on bundle_patches(base_bundle_id)",
-    );
-  }
-
-  return statements;
-};
-
-const enhanceUpwardMigrationResult = (
-  result: MigrationResultLike,
-  provider: ORMSQLProvider,
-  targetVersion: string,
-) => {
-  for (const sql of getMigrationCustomSql(provider, targetVersion)) {
-    addCustomSqlOperation(result, sql);
-  }
-
-  return result;
-};
-
 export const assertBundlePersistenceConstraints = (
   bundle: Pick<
     Bundle,
@@ -353,108 +53,3 @@ export const assertBundlePersistenceConstraints = (
     }
   }
 };
-
-export const enhanceGeneratedSchema = (
-  adapterName: AdapterName,
-  code: string,
-  provider?: ORMProvider,
-) => {
-  if (adapterName === "prisma") {
-    const datasourceProvider = provider ?? getPrismaDatasourceProvider(code);
-    let nextCode = code;
-
-    if (datasourceProvider !== "sqlite") {
-      nextCode = nextCode.replace(
-        /^(\s*metadata\s+Json)(?!\s+@default\("?\{\}"?\))(.*)$/m,
-        '$1 @default("{}")$2',
-      );
-    }
-
-    nextCode = appendPrismaModelLines(
-      nextCode,
-      "bundles",
-      [
-        'patches bundle_patches[] @relation("bundle_patches_bundles_patches")',
-        'baseForPatches bundle_patches[] @relation("bundle_patches_bundles_baseForPatches")',
-      ],
-      {
-        position: "beforeAttributes",
-      },
-    );
-    nextCode = appendPrismaModelLines(nextCode, "bundles", [
-      '@@index([target_app_version], map: "bundles_target_app_version_idx")',
-      '@@index([fingerprint_hash], map: "bundles_fingerprint_hash_idx")',
-      '@@index([channel], map: "bundles_channel_idx")',
-      '@@index([rollout_cohort_count], map: "bundles_rollout_idx")',
-    ]);
-    return appendPrismaModelLines(nextCode, "bundle_patches", [
-      '@@index([bundle_id], map: "bundle_patches_bundle_id_idx")',
-      '@@index([base_bundle_id], map: "bundle_patches_base_bundle_id_idx")',
-    ]);
-  }
-
-  if (adapterName === "drizzle") {
-    let nextCode = ensureDrizzleMetadataDefault(code);
-    nextCode = removeUnusedDrizzleRelationMany(nextCode);
-    nextCode = ensureDrizzleIndexImport(nextCode);
-    nextCode = updateDrizzleTableBlock(nextCode, "bundles", [
-      'index("bundles_target_app_version_idx").on(table.target_app_version),',
-      'index("bundles_fingerprint_hash_idx").on(table.fingerprint_hash),',
-      'index("bundles_channel_idx").on(table.channel),',
-      'index("bundles_rollout_idx").on(table.rollout_cohort_count),',
-    ]);
-    nextCode = updateDrizzleTableBlock(nextCode, "bundle_patches", [
-      'index("bundle_patches_bundle_id_idx").on(table.bundle_id),',
-      'index("bundle_patches_base_bundle_id_idx").on(table.base_bundle_id),',
-    ]);
-    return nextCode;
-  }
-
-  return code;
-};
-
-export const wrapKyselyMigrator = <TMigrator extends MigratorLike>(
-  migrator: TMigrator,
-  provider: ORMSQLProvider | undefined,
-  latestVersion: string,
-): TMigrator => {
-  if (!provider) {
-    return migrator;
-  }
-
-  return {
-    ...migrator,
-    async up(...args: Parameters<TMigrator["up"]>) {
-      const next = await migrator.next();
-      const result = await migrator.up(...args);
-
-      if (next) {
-        enhanceUpwardMigrationResult(result, provider, next.version);
-      }
-
-      return result;
-    },
-    async migrateTo(...args: Parameters<TMigrator["migrateTo"]>) {
-      const version = args[0];
-      const options = args[1];
-      const currentVersion = await migrator.getVersion();
-      const result = await migrator.migrateTo(version, options);
-
-      if (!currentVersion || semver.gt(version, currentVersion)) {
-        enhanceUpwardMigrationResult(result, provider, version);
-      }
-
-      return result;
-    },
-    async migrateToLatest(...args: Parameters<TMigrator["migrateToLatest"]>) {
-      const currentVersion = await migrator.getVersion();
-      const result = await migrator.migrateToLatest(...args);
-
-      if (!currentVersion || semver.gt(latestVersion, currentVersion)) {
-        enhanceUpwardMigrationResult(result, provider, latestVersion);
-      }
-
-      return result;
-    },
-  } as TMigrator;
-};