How to use the graphql-migrations.migrate function in graphql-migrations

export async function initInMemoryDatabase(
  schema: string
): Promise {
  // initialize the knex db
  const knex = Knex({
    client: "sqlite3",
    connection: { filename: ":memory:" }
  });

  // migrate the schema
  const strategy = new DropCreateDatabaseAlways("sqlite3", knex);
  await migrate(schema, strategy);

  return new InMemoryDatabase(knex);
}

export async function createDatabaseMigration(schema: string, config: GenerateConfig) {
  const db = knex({
    client: config.db.database,
    connection: config.db.dbConfig,
  });
  // FIXME move to UpdateDatabaseIfChanges after adding relationships support
  const dbInitialization = new DropCreateDatabaseAlways(config.db.database, db);

  await migrate(schema, dbInitialization);
  return new Promise(resolve => db.destroy(resolve));
}

logError(`No graphql file found inside ${process.cwd()}/model folder.`)
      process.exit(0)
    }

    if (database === 'sqlite3') {
      await execa('touch', ['db.sqlite'])
    }

    const dbConfig = {
      client: config.db.database,
      connection: config.db.dbConfig
    }

    const schemaText = loadSchema(folders.model);

    databaseOperations = await migrate(dbConfig, schemaText, {
      dbSchemaName: config.db.schema
    });

  } catch (err) {
    handleError(err)
  }

  return databaseOperations;
}

export const createRuntime = async (client: Knex) => {
  const schemaText = loadSchema(jsonConfig.folders.model);

  const backend = new GraphQLBackendCreator(schemaText, jsonConfig.graphqlCRUD);
  const dbClientProvider = new PgKnexDBDataProvider(client);

  const dbConfig = {
    client: jsonConfig.db.database,
    connection: jsonConfig.db.dbConfig
  };

  migrate(dbConfig, schemaText, {
    dbSchemaName: jsonConfig.db.schema
  }).then((ops) => {
    console.log(ops);
  });

  const pubSub = new PubSub();
  const runtime = await backend.createRuntime(dbClientProvider, pubSub);
  const generatedSchema = runtime.schema;

  const executableSchema = makeExecutableSchema({
    typeDefs: gql`${generatedSchema}`,
    resolvers: runtime.resolvers,
    resolverValidationOptions: {
      requireResolversForResolveType: false
    }
  });