rake-db 2.25.17 → 2.27.2

package/dist/index.mjs

@@ -1,8 +1,10 @@
-import { DomainColumn, escapeForMigration, ArrayColumn, EnumColumn, defaultSchemaConfig, getColumnTypes, parseTableData, escapeString, tableDataMethods, ColumnType, parseTableDataInput, UnknownColumn, raw, TransactionAdapter, logParamToLogObject, createDb as createDb$1, Adapter, makeColumnTypes, makeColumnsByType, RawSQL, CustomTypeColumn, assignDbDataToColumn, PostgisGeographyPointColumn, pushTableDataCode, primaryKeyInnerToCode, indexInnerToCode, excludeInnerToCode, constraintInnerToCode, referencesArgsToCode, TimestampTZColumn, TimestampColumn } from 'pqb';
-import { singleQuote, toSnakeCase, isRawSQL, toCamelCase, toArray, snakeCaseKey, emptyObject, setCurrentColumnName, consumeColumnName, ColumnTypeBase, setDefaultLanguage, deepCompare, getImportPath, pathToLog, emptyArray, getStackTrace, codeToString, addCode, quoteObjectKey, backtickQuote } from 'orchid-core';
+import { escapeForMigration, ArrayColumn, DomainColumn, EnumColumn, defaultSchemaConfig, getColumnTypes, parseTableData, escapeString, tableDataMethods, ColumnType, parseTableDataInput, UnknownColumn, raw, logParamToLogObject, createDbWithAdapter, makeColumnsByType, RawSQL, CustomTypeColumn, assignDbDataToColumn, PostgisGeographyPointColumn, pushTableDataCode, primaryKeyInnerToCode, indexInnerToCode, excludeInnerToCode, constraintInnerToCode, referencesArgsToCode, TimestampTZColumn, TimestampColumn, makeColumnTypes } from 'pqb';
+import { singleQuote, isRawSQL, toSnakeCase, toCamelCase, toArray, snakeCaseKey, emptyObject, setCurrentColumnName, consumeColumnName, ColumnTypeBase, setDefaultLanguage, deepCompare, getImportPath, pathToLog, emptyArray, codeToString, addCode, quoteObjectKey, backtickQuote, getStackTrace } from 'orchid-core';
 import path, { join } from 'path';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import fs, { mkdir, writeFile, readdir, stat, readFile } from 'fs/promises';
+import 'url';
+import 'node:path';
 
 const getFirstWordAndRest = (input) => {
   const i = input.search(/(?=[A-Z])|[-_ ]/);
@@ -29,12 +31,6 @@ const getTextAfterTo = (input) => {
 const getTextAfterFrom = (input) => {
   return getTextAfterRegExp(input, /(From|-from|_from| from)[A-Z-_ ]/, 4);
 };
-const joinWords = (...words) => {
-  return words.slice(1).reduce(
-    (acc, word) => acc + word[0].toUpperCase() + word.slice(1),
-    words[0]
-  );
-};
 const joinColumns = (columns) => {
   return columns.map((column) => `"${column}"`).join(", ");
 };
@@ -72,26 +68,17 @@ const makePopulateEnumQuery = (item) => {
     }
   };
 };
-const begin = {
-  text: "BEGIN"
-};
 const transaction = (adapter, fn) => {
-  return adapter.transaction(begin, fn);
+  return adapter.transaction(void 0, fn);
 };
 const queryLock = (trx) => trx.query(`SELECT pg_advisory_xact_lock('${RAKE_DB_LOCK_KEY}')`);
-const exhaustive = (_) => {
-  throw new Error("Condition was not exhaustive");
-};
-const pluralize = (w, count, append = "s") => {
-  return count === 1 ? w : w + append;
-};
 
 let currentChanges = [];
 const clearChanges = () => {
   currentChanges = [];
 };
 const getCurrentChanges = () => currentChanges;
-const pushChange = (fn) => currentChanges.push(fn);
+const pushChange = (change) => currentChanges.push(change);
 
 const versionToString = (config, version) => config.migrationId === "timestamp" ? `${version}` : `${version}`.padStart(config.migrationId.serial, "0");
 const columnTypeToSql = (item) => {
@@ -1376,22 +1363,28 @@ const astToQuery = (ast) => {
 };
 
 const createMigrationInterface = (tx, up, config) => {
-  const adapter = new TransactionAdapter(
-    tx,
-    tx.client,
-    tx.types
-  );
-  adapter.schema = adapter.adapter.schema ?? "public";
+  const adapter = Object.create(tx);
+  adapter.schema = adapter.getSchema() ?? "public";
   const { query, arrays } = adapter;
   const log = logParamToLogObject(config.logger || console, config.log);
-  adapter.query = (q, types) => {
-    return wrapWithLog(log, q, () => query.call(adapter, q, types));
+  adapter.query = (text, values) => {
+    return wrapWithLog(
+      log,
+      text,
+      values,
+      () => query.call(adapter, text, values)
+    );
   };
-  adapter.arrays = (q, types) => {
-    return wrapWithLog(log, q, () => arrays.call(adapter, q, types));
+  adapter.arrays = (text, values) => {
+    return wrapWithLog(
+      log,
+      text,
+      values,
+      () => arrays.call(adapter, text, values)
+    );
   };
   Object.assign(adapter, { silentQuery: query, silentArrays: arrays });
-  const db = createDb$1({
+  const db = createDbWithAdapter({
     adapter,
     columnTypes: config.columnTypes
   });
@@ -2231,11 +2224,14 @@ class Migration {
     });
   }
 }
-const wrapWithLog = async (log, query, fn) => {
+const wrapWithLog = async (log, text, values, fn) => {
   if (!log) {
     return fn();
   } else {
-    const sql = typeof query === "string" ? { text: query, values: [] } : query.values ? query : { ...query, values: [] };
+    const sql = {
+      text,
+      values: values || []
+    };
     const logData = log.beforeQuery(sql);
     try {
       const result = await fn();
@@ -2382,7 +2378,7 @@ const createCollation = async (migration, up, name, options) => {
   await migration.adapter.query(query);
 };
 const queryExists = (db, sql) => {
-  return db.adapter.query(sql).then(({ rowCount }) => rowCount > 0);
+  return db.adapter.query(sql.text, sql.values).then(({ rowCount }) => rowCount > 0);
 };
 const renameType = async (migration, from, to, kind) => {
   const [fromSchema, f] = getSchemaAndTableFromName(migration.up ? from : to);
@@ -2605,7 +2601,7 @@ const fileNamesToChangeMigrationId = {
 const fileNamesToChangeMigrationIdMap = Object.fromEntries(
   Object.entries(fileNamesToChangeMigrationId).map(([_, name]) => [name, true])
 );
-const changeIds = async (options, config, [arg, digitsArg]) => {
+const changeIds = async (adapters, config, [arg, digitsArg]) => {
   if (arg !== "serial" && arg !== "timestamp") {
     throw new Error(
       `Pass "serial" or "timestamp" argument to the "change-ids" command`
@@ -2692,12 +2688,13 @@ After setting \`renameMigrations\` (see above) and renaming the files, run the d
       );
     })
   );
-  await options.map((opts) => {
-    const adapter = new Adapter(opts);
-    renameMigrationVersionsInDb(config, adapter, values).then(
-      () => adapter.close()
-    );
-  });
+  await Promise.all(
+    adapters.map((adapter) => {
+      renameMigrationVersionsInDb(config, adapter, values).then(
+        () => adapter.close()
+      );
+    })
+  );
   config.logger?.log(
     `Migration files were renamed, a config file ${fileNamesToChangeMigrationId[arg]} for renaming migrations after deploy was created, and migrations in local db were renamed successfully.
 
@@ -2705,14 +2702,14 @@ ${arg === "timestamp" || digits !== 4 ? `Set \`migrationId\`: ${arg === "timesta
   );
 };
 const renameMigrationVersionsInDb = async (config, adapter, values) => {
-  await adapter.arrays({
-    text: `UPDATE "${config.migrationsTable}" AS t SET version = v.version FROM (VALUES ${values.map(
+  await adapter.arrays(
+    `UPDATE "${config.migrationsTable}" AS t SET version = v.version FROM (VALUES ${values.map(
       ([oldVersion, , newVersion], i) => `('${oldVersion}', $${i + 1}, '${newVersion}')`
     ).join(
       ", "
     )}) v(oldVersion, name, version) WHERE t.version = v.oldVersion`,
-    values: values.map(([, name]) => name)
-  });
+    values.map(([, name]) => name)
+  );
 };
 
 const getMigrations = async (ctx, config, up, allowDuplicates, getVersion = getMigrationVersionOrThrow) => {
@@ -2870,16 +2867,16 @@ function getDigitsPrefix(name) {
 }
 
 const saveMigratedVersion = async (db, version, name, config) => {
-  await db.silentArrays({
-    text: `INSERT INTO "${config.migrationsTable}"(version, name) VALUES ($1, $2)`,
-    values: [version, name]
-  });
+  await db.silentArrays(
+    `INSERT INTO "${config.migrationsTable}"(version, name) VALUES ($1, $2)`,
+    [version, name]
+  );
 };
 const deleteMigratedVersion = async (db, version, name, config) => {
-  const res = await db.silentArrays({
-    text: `DELETE FROM "${config.migrationsTable}" WHERE version = $1 AND name = $2`,
-    values: [version, name]
-  });
+  const res = await db.silentArrays(
+    `DELETE FROM "${config.migrationsTable}" WHERE version = $1 AND name = $2`,
+    [version, name]
+  );
   if (res.rowCount === 0) {
     throw new Error(`Migration ${version}_${name} was not found in db`);
   }
@@ -2912,10 +2909,10 @@ const getMigratedVersionsMap = async (ctx, adapter, config, renameTo) => {
       await adapter.arrays(`ALTER TABLE ${table} ADD COLUMN name TEXT`);
       await Promise.all(
         result.rows.map(
-          ([version, name]) => adapter.arrays({
-            text: `UPDATE ${table} SET name = $2 WHERE version = $1`,
-            values: [version, name]
-          })
+          ([version, name]) => adapter.arrays(`UPDATE ${table} SET name = $2 WHERE version = $1`, [
+            version,
+            name
+          ])
         )
       );
       await adapter.arrays(
@@ -2991,89 +2988,88 @@ const createMigrationsTable = async (db, config) => {
 };
 
 const RAKE_DB_LOCK_KEY = "8582141715823621641";
-function makeMigrateFn(defaultCount, up, fn) {
-  return async (ctx, options, config, args = [], adapters = options.map((opts) => new Adapter(opts)), dontClose) => {
-    const set = await getMigrations(ctx, config, up);
-    const arg = args[0];
-    let force = arg === "force";
-    let count;
-    if (arg === "force") {
-      force = true;
-    } else {
-      force = false;
-      const num = arg === "all" ? Infinity : parseInt(arg);
-      count = isNaN(num) ? void 0 : num;
-    }
-    const conf = config;
-    const length = options.length;
-    for (let i = 0; i < length; i++) {
-      const opts = options[i];
-      const adapter = adapters[i];
-      let migrations;
-      try {
-        await transaction(adapter, async (trx) => {
+function makeMigrateFn(up, fn) {
+  return async (params) => {
+    const ctx = params.ctx || {};
+    const set = await getMigrations(ctx, params.config, up);
+    const count = params.count ?? Infinity;
+    const force = params.force ?? false;
+    let migrations;
+    try {
+      await transaction(params.adapter, async (trx) => {
+        const versions = await getMigratedVersionsMap(
+          ctx,
+          trx,
+          params.config,
+          set.renameTo
+        );
+        migrations = await fn(trx, params.config, set, versions, count, force);
+      });
+    } catch (err) {
+      if (err instanceof NoMigrationsTableError) {
+        await transaction(params.adapter, async (trx) => {
+          await createMigrationsTable(trx, params.config);
           const versions = await getMigratedVersionsMap(
             ctx,
             trx,
-            config,
+            params.config,
             set.renameTo
           );
           migrations = await fn(
             trx,
-            conf,
+            params.config,
             set,
             versions,
-            count ?? defaultCount,
+            count,
             force
           );
         });
-      } catch (err) {
-        if (err instanceof NoMigrationsTableError) {
-          await transaction(adapter, async (trx) => {
-            const config2 = conf;
-            await createMigrationsTable(trx, config2);
-            const versions = await getMigratedVersionsMap(
-              ctx,
-              trx,
-              config2,
-              set.renameTo
-            );
-            migrations = await fn(
-              trx,
-              config2,
-              set,
-              versions,
-              count ?? defaultCount,
-              force
-            );
-          });
-        } else {
-          throw err;
-        }
-      } finally {
-        if (!dontClose) await adapter.close();
+      } else {
+        throw err;
       }
-      config.afterChangeCommit?.({
-        options: opts,
-        up,
-        migrations
-      });
     }
-    return adapters;
+    params.config.afterChangeCommit?.({
+      adapter: params.adapter,
+      up,
+      migrations
+    });
   };
 }
+const makeMigrateCommand = (migrateFn, defaultCount) => {
+  return async (adapters, config, args) => {
+    const arg = args[0];
+    let force = arg === "force";
+    let count = defaultCount;
+    if (arg === "force") {
+      force = true;
+    } else {
+      force = false;
+      const num = arg === "all" ? Infinity : parseInt(arg || "");
+      if (!isNaN(num)) {
+        count = num;
+      }
+    }
+    for (const adapter of adapters) {
+      await migrateFn({ ctx: {}, adapter, config, count, force });
+      await adapter.close();
+    }
+  };
+};
 const migrate = makeMigrateFn(
-  Infinity,
   true,
   (trx, config, set, versions, count, force) => migrateOrRollback(trx, config, set, versions, count, true, false, force)
 );
+const migrateAndClose = async (params) => {
+  await migrate(params);
+  await params.adapter.close();
+};
+const migrateCommand = makeMigrateCommand(migrate, Infinity);
 const rollback = makeMigrateFn(
-  1,
   false,
   (trx, config, set, versions, count, force) => migrateOrRollback(trx, config, set, versions, count, false, false, force)
 );
+const rollbackCommand = makeMigrateCommand(rollback, 1);
 const redo = makeMigrateFn(
-  1,
   true,
   async (trx, config, set, versions, count, force) => {
     set.migrations.reverse();
@@ -3092,7 +3088,8 @@ const redo = makeMigrateFn(
     );
   }
 );
-const getDb = (adapter) => createDb$1({ adapter });
+const redoCommand = makeMigrateCommand(redo, 1);
+const getDb = (adapter) => createDbWithAdapter({ adapter });
 const migrateOrRollback = async (trx, config, set, versions, count, up, redo2, force, skipLock) => {
   const { sequence, map: versionsMap } = versions;
   if (up) {
@@ -3138,11 +3135,13 @@ const migrateOrRollback = async (trx, config, set, versions, count, up, redo2, f
     if (!loggedAboutStarting && (!redo2 || !up)) {
       loggedAboutStarting = true;
       config.logger?.log(
-        `${redo2 ? "Reapplying migrations for" : up ? "Migrating" : "Rolling back"} database ${trx.config.connectionString ? new URL(trx.config.connectionString).pathname.slice(1) : trx.config.database}
+        `${redo2 ? "Reapplying migrations for" : up ? "Migrating" : "Rolling back"} database ${trx.getDatabase()}
 `
       );
     }
-    await runMigration(trx, up, file, config);
+    const changes = await getChanges(file, config);
+    const adapter = await runMigration(trx, up, changes, config);
+    await changeMigratedVersion(adapter, up, file, config);
     (migrations ?? (migrations = [])).push(file);
     if (up) {
       const name = path.basename(file.path);
@@ -3204,117 +3203,43 @@ Run \`**db command** up force\` to rollback the above migrations and migrate all
   return;
 };
 const changeCache = {};
-const runMigration = async (trx, up, file, config) => {
+const getChanges = async (file, config) => {
   clearChanges();
-  let changes = changeCache[file.path];
+  let changes = file.path ? changeCache[file.path] : void 0;
   if (!changes) {
     const module = await file.load();
     const exported = module?.default && toArray(module.default);
-    if (config.forceDefaultExports && !exported) {
+    if (config?.forceDefaultExports && !exported) {
       throw new RakeDbError(
         `Missing a default export in ${file.path} migration`
       );
     }
     changes = exported || getCurrentChanges();
-    changeCache[file.path] = changes;
+    if (file.path) changeCache[file.path] = changes;
   }
+  return changes;
+};
+const runMigration = async (trx, up, changes, config) => {
   const db = createMigrationInterface(trx, up, config);
   if (changes.length) {
     const from = up ? 0 : changes.length - 1;
     const to = up ? changes.length : -1;
     const step = up ? 1 : -1;
     for (let i = from; i !== to; i += step) {
-      await changes[i](db, up);
+      await changes[i].fn(db, up);
     }
   }
+  return db.adapter;
+};
+const changeMigratedVersion = async (adapter, up, file, config) => {
   await (up ? saveMigratedVersion : deleteMigratedVersion)(
-    db.adapter,
+    adapter,
     file.version,
     path.basename(file.path).slice(file.version.length + 1),
     config
   );
 };
 
-const migrationConfigDefaults = {
-  schemaConfig: defaultSchemaConfig,
-  migrationsPath: path.join("src", "db", "migrations"),
-  migrationId: { serial: 4 },
-  migrationsTable: "schemaMigrations",
-  snakeCase: false,
-  commands: {},
-  log: true,
-  logger: console,
-  import() {
-    throw new Error("Please define the `import` setting in `rakeDb` config");
-  }
-};
-const processRakeDbConfig = (config) => {
-  const result = { ...migrationConfigDefaults, ...config };
-  if (!result.recurrentPath) {
-    result.recurrentPath = path.join(result.migrationsPath, "recurrent");
-  }
-  if (!result.log) {
-    delete result.logger;
-  }
-  if (!result.basePath || !result.dbScript) {
-    let filePath = getStackTrace()?.[3].getFileName();
-    if (!filePath) {
-      throw new Error(
-        "Failed to determine path to db script. Please set basePath option of rakeDb"
-      );
-    }
-    if (filePath.startsWith("file://")) {
-      filePath = fileURLToPath(filePath);
-    }
-    const ext = path.extname(filePath);
-    if (ext !== ".ts" && ext !== ".js" && ext !== ".mjs") {
-      throw new Error(
-        `Add a .ts suffix to the "${path.basename(filePath)}" when calling it`
-      );
-    }
-    result.basePath = path.dirname(filePath);
-    result.dbScript = path.basename(filePath);
-  }
-  if ("migrationsPath" in result && !path.isAbsolute(result.migrationsPath)) {
-    result.migrationsPath = path.resolve(
-      result.basePath,
-      result.migrationsPath
-    );
-  }
-  if ("recurrentPath" in result && !path.isAbsolute(result.recurrentPath)) {
-    result.recurrentPath = path.resolve(result.basePath, result.recurrentPath);
-  }
-  if ("baseTable" in config && config.baseTable) {
-    const { types, snakeCase, language } = config.baseTable.prototype;
-    result.columnTypes = types || makeColumnTypes(defaultSchemaConfig);
-    if (snakeCase) result.snakeCase = true;
-    if (language) result.language = language;
-  } else {
-    const ct = "columnTypes" in config && config.columnTypes;
-    result.columnTypes = (typeof ct === "function" ? ct(
-      makeColumnTypes(defaultSchemaConfig)
-    ) : ct) || makeColumnTypes(defaultSchemaConfig);
-  }
-  if (config.migrationId === "serial") {
-    result.migrationId = { serial: 4 };
-  }
-  return result;
-};
-const getDatabaseAndUserFromOptions = (options) => {
-  if (options.databaseURL) {
-    const url = new URL(options.databaseURL);
-    return {
-      database: url.pathname.slice(1),
-      user: url.username
-    };
-  } else {
-    return {
-      database: options.database,
-      user: options.user
-    };
-  }
-};
-
 const colors = {
   yellow: (s) => `\x1B[33m${s}\x1B[0m`,
   green: (s) => `\x1B[32m${s}\x1B[0m`,
@@ -3502,52 +3427,9 @@ const promptText = ({
   });
 };
 
-const setAdapterOptions = (options, set) => {
-  if (options.databaseURL) {
-    const url = new URL(options.databaseURL);
-    if ("database" in set) {
-      url.pathname = `/${set.database}`;
-    }
-    if (set.user !== void 0) {
-      url.username = set.user;
-    }
-    if (set.password !== void 0) {
-      url.password = set.password;
-    }
-    return { ...options, databaseURL: url.toString() };
-  } else {
-    return {
-      ...options,
-      ...set
-    };
-  }
-};
-const setAdminCredentialsToOptions = async (options, create) => {
-  const ok = await promptConfirm({
-    message: `Would you like to share admin credentials to ${create ? "create" : "drop"} a database?`
-  });
-  if (!ok) {
-    return;
-  }
-  const user = await promptText({
-    message: "Enter admin user:",
-    default: "postgres",
-    min: 1
-  });
-  const password = await promptText({
-    message: "Enter admin password:",
-    password: true
-  });
-  return setAdapterOptions(options, {
-    user,
-    password: password || void 0
-  });
-};
-
-const execute = async (options, sql) => {
-  const db = new Adapter(options);
+const execute = async (adapter, sql) => {
   try {
-    await db.query(sql);
+    await adapter.query(sql);
     return "ok";
   } catch (error) {
     const err = error;
@@ -3562,13 +3444,16 @@ const execute = async (options, sql) => {
       return { error };
     }
   } finally {
-    await db.close();
+    await adapter.close();
   }
 };
-const createOrDrop = async (options, adminOptions, config, args) => {
-  const params = getDatabaseAndUserFromOptions(options);
+const createOrDrop = async (adapter, adminAdapter, config, args) => {
+  const params = {
+    database: adapter.getDatabase(),
+    user: adapter.getUser()
+  };
   const result = await execute(
-    setAdapterOptions(adminOptions, { database: "postgres" }),
+    adminAdapter.reconfigure({ database: "postgres" }),
     args.sql(params)
   );
   if (result === "ok") {
@@ -3582,31 +3467,28 @@ const createOrDrop = async (options, adminOptions, config, args) => {
     return;
   } else if (result === "forbidden") {
     let message = `Permission denied to ${args.create ? "create" : "drop"} database.`;
-    const host = adminOptions.databaseURL ? new URL(adminOptions.databaseURL).hostname : adminOptions.host;
+    const host = adminAdapter.getHost();
     const isLocal = host === "localhost";
     if (!isLocal) {
       message += `
 Don't use this command for database service providers, only for a local db.`;
     }
     config.logger?.log(message);
-    const updatedOptions = await setAdminCredentialsToOptions(
-      options,
-      args.create
-    );
-    if (!updatedOptions) return;
-    await createOrDrop(options, updatedOptions, config, args);
+    const params2 = await askForAdminCredentials(args.create);
+    if (!params2) return;
+    await createOrDrop(adapter, adminAdapter.reconfigure(params2), config, args);
     return;
   } else {
     throw result.error;
   }
   if (!args.create) return;
-  const db = new Adapter(options);
-  await createMigrationsTable(db, config);
-  await db.close();
+  const newlyConnectedAdapter = adapter.reconfigure({});
+  await createMigrationsTable(newlyConnectedAdapter, config);
+  await newlyConnectedAdapter.close();
 };
-const createDb = async (options, config) => {
-  for (const opts of options) {
-    await createOrDrop(opts, opts, config, {
+const createDb = async (adapters, config) => {
+  for (const adapter of adapters) {
+    await createOrDrop(adapter, adapter, config, {
       sql({ database, user }) {
         return `CREATE DATABASE "${database}"${user ? ` OWNER "${user}"` : ""}`;
       },
@@ -3620,9 +3502,9 @@ const createDb = async (options, config) => {
     });
   }
 };
-const dropDb = async (options, config) => {
-  for (const opts of options) {
-    await createOrDrop(opts, opts, config, {
+const dropDb = async (adapters, config) => {
+  for (const adapter of adapters) {
+    await createOrDrop(adapter, adapter, config, {
       sql({ database }) {
         return `DROP DATABASE "${database}"`;
       },
@@ -3635,10 +3517,33 @@ const dropDb = async (options, config) => {
     });
   }
 };
-const resetDb = async (options, config) => {
-  await dropDb(options, config);
-  await createDb(options, config);
-  await migrate({}, options, config);
+const resetDb = async (adapters, config) => {
+  await dropDb(adapters, config);
+  await createDb(adapters, config);
+  for (const adapter of adapters) {
+    await migrateAndClose({ adapter, config });
+  }
+};
+const askForAdminCredentials = async (create) => {
+  const ok = await promptConfirm({
+    message: `Would you like to share admin credentials to ${create ? "create" : "drop"} a database?`
+  });
+  if (!ok) {
+    return;
+  }
+  const user = await promptText({
+    message: "Enter admin user:",
+    default: "postgres",
+    min: 1
+  });
+  const password = await promptText({
+    message: "Enter admin password:",
+    password: true
+  });
+  return {
+    user,
+    password: password || void 0
+  };
 };
 
 const filterSchema = (table) => `${table} !~ '^pg_' AND ${table} != 'information_schema'`;
@@ -4602,6 +4507,10 @@ const checkIfIsOuterRecursiveFkey = (data, table, references) => {
   return false;
 };
 
+const exhaustive = (_) => {
+  throw new Error("Condition was not exhaustive");
+};
+
 const astToGenerateItems = (config, asts, currentSchema) => {
   return asts.map((ast) => astToGenerateItem(config, ast, currentSchema));
 };
@@ -5347,8 +5256,7 @@ const timestampsToCode = ({ hasTZTimestamps }) => {
   return `t.${key}()`;
 };
 
-const pullDbStructure = async (options, config) => {
-  const adapter = new Adapter(options);
+const pullDbStructure = async (adapter, config) => {
   const currentSchema = adapter.schema || "public";
   const ctx = makeStructureToAstCtx(config, currentSchema);
   const ast = await structureToAst(ctx, adapter, config);
@@ -5379,12 +5287,12 @@ Append \`as\` method manually to ${count > 1 ? "these" : "this"} column${count >
   adapter.close();
 };
 
-const runRecurrentMigrations = async (options, config) => {
+const runRecurrentMigrations = async (adapters, config) => {
   let dbs;
   let files = 0;
   await readdirRecursive(config.recurrentPath, async (path) => {
     files++;
-    dbs ?? (dbs = options.map((opts) => createDb$1({ adapter: new Adapter(opts) })));
+    dbs ?? (dbs = adapters.map((adapter) => createDbWithAdapter({ adapter })));
     const sql = await readFile(path, "utf-8");
     await Promise.all(
       dbs.map(async (db) => {
@@ -5420,8 +5328,7 @@ const readdirRecursive = async (dirPath, cb) => {
   );
 };
 
-const listMigrationsStatuses = async (options, config, args) => {
-  const adapters = options.map((opts) => new Adapter(opts));
+const listMigrationsStatuses = async (adapters, config, args) => {
   const ctx = {};
   const [{ migrations }, ...migrated] = await Promise.all([
     getMigrations(ctx, config, true),
@@ -5430,10 +5337,10 @@ const listMigrationsStatuses = async (options, config, args) => {
   const map = {};
   let maxVersionLength = 12;
   let maxNameLength = 4;
-  for (let i = 0; i < options.length; i++) {
+  for (let i = 0; i < adapters.length; i++) {
     const list = migrated[i];
     const key = Object.entries(list.map).map(([version, up]) => `${version}${up ? "t" : "f"}`).join("");
-    const database = options[i].database || new URL(options[i].databaseURL).pathname.slice(1);
+    const database = adapters[i].getDatabase();
     if (map[key]) {
       map[key].databases.push(database);
       continue;
@@ -5512,7 +5419,88 @@ const makeChars = (count, char) => {
   return chars;
 };
 
-const rebase = async (options, config) => {
+const migrationConfigDefaults = {
+  schemaConfig: defaultSchemaConfig,
+  migrationsPath: path.join("src", "db", "migrations"),
+  migrationId: { serial: 4 },
+  migrationsTable: "schemaMigrations",
+  snakeCase: false,
+  commands: {},
+  log: true,
+  logger: console,
+  import() {
+    throw new Error(
+      "Add `import: (path) => import(path),` setting to `rakeDb` config"
+    );
+  }
+};
+const ensureMigrationsPath = (config) => {
+  if (!config.migrationsPath) {
+    config.migrationsPath = migrationConfigDefaults.migrationsPath;
+  }
+  if (!path.isAbsolute(config.migrationsPath)) {
+    config.migrationsPath = path.resolve(
+      config.basePath,
+      config.migrationsPath
+    );
+  }
+  return config;
+};
+const ensureBasePathAndDbScript = (config, intermediateCallers = 0) => {
+  if (config.basePath && config.dbScript) return config;
+  let filePath = getStackTrace()?.[3 + intermediateCallers].getFileName();
+  if (!filePath) {
+    throw new Error(
+      "Failed to determine path to db script. Please set basePath option of rakeDb"
+    );
+  }
+  if (filePath.startsWith("file://")) {
+    filePath = fileURLToPath(filePath);
+  }
+  const ext = path.extname(filePath);
+  if (ext !== ".ts" && ext !== ".js" && ext !== ".mjs") {
+    throw new Error(
+      `Add a .ts suffix to the "${path.basename(filePath)}" when calling it`
+    );
+  }
+  config.basePath = path.dirname(filePath);
+  config.dbScript = path.basename(filePath);
+  return config;
+};
+const processRakeDbConfig = (config) => {
+  const result = { ...migrationConfigDefaults, ...config };
+  if (!result.log) {
+    delete result.logger;
+  }
+  ensureBasePathAndDbScript(result, 1);
+  ensureMigrationsPath(result);
+  if (!result.recurrentPath) {
+    result.recurrentPath = path.join(
+      result.migrationsPath,
+      "recurrent"
+    );
+  }
+  if ("recurrentPath" in result && !path.isAbsolute(result.recurrentPath)) {
+    result.recurrentPath = path.resolve(result.basePath, result.recurrentPath);
+  }
+  if ("baseTable" in config && config.baseTable) {
+    const { types, snakeCase, language } = config.baseTable.prototype;
+    result.columnTypes = types || makeColumnTypes(defaultSchemaConfig);
+    if (snakeCase) result.snakeCase = true;
+    if (language) result.language = language;
+  } else {
+    const ct = "columnTypes" in config && config.columnTypes;
+    result.columnTypes = (typeof ct === "function" ? ct(
+      makeColumnTypes(defaultSchemaConfig)
+    ) : ct) || makeColumnTypes(defaultSchemaConfig);
+  }
+  if (config.migrationId === "serial") {
+    result.migrationId = { serial: 4 };
+  }
+  return result;
+};
+
+const rebase = async (adapters, config) => {
   if (config.migrations) {
     throw new Error("Cannot rebase migrations defined in the config");
   }
@@ -5521,7 +5509,6 @@ const rebase = async (options, config) => {
       `Cannot rebase when the 'migrationId' is set to 'timestamp' in the config`
     );
   }
-  const adapters = options.map((opts) => new Adapter(opts));
   const ctx = {};
   const [set, ...versionMaps] = await Promise.all([
     await getMigrations(ctx, config, true, true),
@@ -5642,20 +5629,23 @@ const rebase = async (options, config) => {
     return files2;
   }, []).sort((a, b) => +b.version - +a.version);
   set.migrations = migrationsDown;
-  await redo(
-    ctx,
-    options,
-    {
-      ...config,
-      async afterRollback() {
-        set.migrations = migrationsUp;
-      },
-      async afterMigrate() {
-        set.migrations = migrationsDown;
-      }
+  const redoConfig = {
+    ...config,
+    async afterRollback() {
+      set.migrations = migrationsUp;
     },
-    ["all"]
-  );
+    async afterMigrate() {
+      set.migrations = migrationsDown;
+    }
+  };
+  for (const adapter of adapters) {
+    await redo({
+      ctx,
+      adapter,
+      config: redoConfig
+    });
+    await adapter.close();
+  }
   for (let i = renames.length - 1; i >= 0; i--) {
     const [from, version] = renames[i];
     const prefix = String(version).padStart(4, "0");
@@ -5669,10 +5659,10 @@ const rebase = async (options, config) => {
   }
 };
 
-const rakeDb = (options, partialConfig, args = process.argv.slice(2)) => {
+const rakeDbWithAdapters = (adapters, partialConfig, args = process.argv.slice(2)) => {
   const config = processRakeDbConfig(partialConfig);
   const promise = runCommand(
-    options,
+    adapters,
     config,
     args
   ).catch((err) => {
@@ -5682,40 +5672,40 @@ const rakeDb = (options, partialConfig, args = process.argv.slice(2)) => {
     }
     throw err;
   });
-  return Object.assign(change, {
+  return Object.assign(makeChange(config), {
     promise
   });
 };
-rakeDb.lazy = (options, partialConfig) => {
+rakeDbWithAdapters.lazy = (adapters, partialConfig) => {
   const config = processRakeDbConfig(partialConfig);
   return {
-    change,
+    change: makeChange(config),
     run(args, conf) {
-      return runCommand(options, conf ? { ...config, ...conf } : config, args);
+      return runCommand(adapters, conf ? { ...config, ...conf } : config, args);
     }
   };
 };
-function change(fn) {
-  pushChange(fn);
-  return fn;
-}
+const makeChange = (config) => (fn) => {
+  const change = { fn, config };
+  pushChange(change);
+  return change;
+};
 const rakeDbAliases = {
   migrate: "up",
   rollback: "down",
   s: "status",
   rec: "recurrent"
 };
-const runCommand = async (opts, config, args = process.argv.slice(2)) => {
+const runCommand = async (adapters, config, args = process.argv.slice(2)) => {
   let arg = args[0]?.split(":")[0];
   if (rakeDbAliases[arg]) {
     args = [...args];
     arg = args[0] = rakeDbAliases[arg];
   }
-  const options = toArray(opts);
   args.shift();
   const command = rakeDbCommands[arg]?.run ?? config.commands[arg];
   if (command) {
-    await command(options, config, args);
+    await command(adapters, config, args);
   } else if (config.logger) {
     const commandsHelp = [];
     let max = 0;
@@ -5770,14 +5760,14 @@ ${Object.entries(helpArguments).map(
 `);
   }
   return {
-    options,
+    adapters,
     config,
     args
   };
 };
 const upCommand = {
-  run: (options, config, args) => migrate({}, options, config, args).then(
-    () => runRecurrentMigrations(options, config)
+  run: (adapters, config, args) => migrateCommand(adapters, config, args).then(
+    () => runRecurrentMigrations(adapters, config)
   ),
   help: "migrate pending migrations",
   helpArguments: {
@@ -5787,7 +5777,7 @@ const upCommand = {
   }
 };
 const downCommand = {
-  run: (options, config, args) => rollback({}, options, config, args),
+  run: (adapters, config, args) => rollbackCommand(adapters, config, args),
   help: "rollback migrated migrations",
   helpArguments: {
     "no arguments": "rollback one last migration",
@@ -5817,8 +5807,8 @@ const rakeDbCommands = {
     help: "drop databases"
   },
   reset: {
-    run: (options, config) => resetDb(options, config).then(
-      () => runRecurrentMigrations(options, config)
+    run: (adapters, config) => resetDb(adapters, config).then(
+      () => runRecurrentMigrations(adapters, config)
     ),
     help: "drop, create and migrate databases"
   },
@@ -5827,13 +5817,13 @@ const rakeDbCommands = {
   down: downCommand,
   rollback: downCommand,
   redo: {
-    run: (options, config, args) => redo({}, options, config, args).then(
-      () => runRecurrentMigrations(options, config)
+    run: (adapters, config, args) => redoCommand(adapters, config, args).then(
+      () => runRecurrentMigrations(adapters, config)
     ),
     help: "rollback and migrate, run recurrent"
   },
   pull: {
-    run: ([options], config) => pullDbStructure(options, config),
+    run: ([adapter], config) => pullDbStructure(adapter, config),
     help: "generate a combined migration for an existing database"
   },
   new: {
@@ -5859,5 +5849,18 @@ const rakeDbCommands = {
   }
 };
 
-export { Migration, NoMigrationsTableError, RAKE_DB_LOCK_KEY, addColumnComment, addColumnExclude, addColumnIndex, addOrDropEnumValues, astToMigration, changeCache, changeEnumValues, clearChanges, cmpRawSql, colors, columnToSql, columnTypeToSql, commentsToQuery, concatSchemaAndName, constraintToSql, createDb, createMigrationInterface, dbColumnToAst, deleteMigratedVersion, dropDb, encodeColumnDefault, excludesToQuery, exhaustive, generateTimeStamp, getColumnName, getConstraintName, getCurrentChanges, getDatabaseAndUserFromOptions, getDbStructureTableData, getDbTableColumnsChecks, getExcludeName, getFirstWordAndRest, getForeignKeyTable, getIndexName, getMigratedVersionsMap, getSchemaAndTableFromName, getTextAfterFrom, getTextAfterTo, identityToSql, indexesToQuery, instantiateDbColumn, interpolateSqlValues, introspectDbSchema, joinColumns, joinWords, makeDbStructureColumnsShape, makeDomainsMap, makeFileVersion, makePopulateEnumQuery, makeStructureToAstCtx, migrate, migrateOrRollback, migrationConfigDefaults, nameColumnChecks, newMigration, pluralize, primaryKeyToSql, processRakeDbConfig, promptConfirm, promptSelect, promptText, pushChange, queryLock, quoteCustomType, quoteNameFromString, quoteSchemaTable, quoteTable, quoteWithSchema, rakeDb, rakeDbAliases, rakeDbCommands, redo, referencesToSql, renameType, resetDb, rollback, saveMigratedVersion, structureToAst, tableToAst, transaction, versionToString, writeMigrationFile };
+const migrateFiles = async (db, files) => {
+  const qb = db.$qb;
+  await qb.ensureTransaction(async () => {
+    const adapter = qb.internal.transactionStorage.getStore()?.adapter;
+    for (const load of files) {
+      clearChanges();
+      const changes = await getChanges({ load });
+      const config = changes[0]?.config;
+      await runMigration(adapter, true, changes, config);
+    }
+  });
+};
+
+export { astToMigration, concatSchemaAndName, createMigrationInterface, dbColumnToAst, encodeColumnDefault, getConstraintName, getDbStructureTableData, getDbTableColumnsChecks, getExcludeName, getIndexName, getSchemaAndTableFromName, instantiateDbColumn, introspectDbSchema, makeDomainsMap, makeFileVersion, makeStructureToAstCtx, migrate, migrateAndClose, migrateFiles, migrationConfigDefaults, promptSelect, rakeDbCommands, rakeDbWithAdapters, saveMigratedVersion, structureToAst, tableToAst, writeMigrationFile };
 //# sourceMappingURL=index.mjs.map