Function migrateTo

packages/core/fumadb/src/migration-engine/create.ts:217–305

(version, options = {})

      return this.migrateTo(prev.version, options);
    },
    async migrateTo(version, options = {}) {
      const {
        updateSettings: updateVersion = true,
        unsafe = false,
        mode = "from-schema",
      } = options;
      const targetSchema = getSchemaByVersion(version);
      const currentSchema = await getCurrentSchema();

      let run:
        | ((context: MigrationContext) => Awaitable<MigrationOperation[]>)
        | undefined;

      // same variant
      const prevVariant = parse(targetSchema.version)!.prerelease;
      const variant = parse(currentSchema.version)!.prerelease;

      if (deepEqual(prevVariant, variant)) {
        const list = getSchemasOfVariant(variant);
        const targetIdx = list.indexOf(targetSchema);

        switch (currentSchema.version) {
          case list[targetIdx - 1]?.version:
            run = targetSchema.up;
            break;
          case list[targetIdx + 1]?.version:
            run = targetSchema.down;
            break;
        }
      }

      run ??= (context) => context.auto();

      const context: MigrationContext = {
        async auto() {
          let generated: MigrationOperation[];

          if (mode === "from-schema") {
            generated = generateMigrationFromSchema(
              currentSchema,
              targetSchema,
              userConfig
            );
          } else {
            if (!generateMigrationFromDatabase)
              throw new Error(`${mode} is not supported for this adapter.`);

            generated = await generateMigrationFromDatabase({
              target: targetSchema,
              dropUnusedColumns: unsafe,
            });
          }

          for (const transformer of transformers) {
            if (!transformer.afterAuto) continue;

            generated = transformer.afterAuto(generated, {
              prev: currentSchema,