rake-db 2.0.0 → 2.0.2

package/dist/index.esm.js

@@ -1,27 +1,28 @@
-import { toArray, Adapter } from 'pqb';
+import { toArray, Adapter, quote, isRaw, getRaw, getColumnTypes, columnTypes, getTableData, ColumnType, Operators, resetTableData, emptyObject, TransactionAdapter, logParamToLogObject } from 'pqb';
 import Enquirer from 'enquirer';
 import path from 'path';
-import 'fs/promises';
+import { readdir, mkdir, writeFile } from 'fs/promises';
+import { singular } from 'pluralize';
 
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
+var __defProp$3 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
 const migrationConfigDefaults = {
   migrationsPath: path.resolve(process.cwd(), "src", "migrations"),
   migrationsTable: "schemaMigrations",
@@ -30,7 +31,12 @@ const migrationConfigDefaults = {
       require("ts-node").register({ compilerOptions: { module: "CommonJS" } });
     }
     require(path2);
-  }
+  },
+  log: true,
+  logger: console
+};
+const getMigrationConfigWithDefaults = (config) => {
+  return __spreadValues$3(__spreadValues$3({}, migrationConfigDefaults), config);
 };
 const getDatabaseAndUserFromOptions = (options) => {
   if (options.connectionString) {
@@ -58,9 +64,9 @@ const setAdapterOptions = (options, set) => {
     if (set.password !== void 0) {
       url.password = set.password;
     }
-    return __spreadProps(__spreadValues({}, options), { connectionString: url.toString() });
+    return __spreadProps$3(__spreadValues$3({}, options), { connectionString: url.toString() });
   } else {
-    return __spreadValues(__spreadValues({}, options), set);
+    return __spreadValues$3(__spreadValues$3({}, options), set);
   }
 };
 const askAdminCredentials = async () => {
@@ -93,7 +99,9 @@ const setAdminCredentialsToOptions = async (options) => {
 const createSchemaMigrations = async (db, config) => {
   try {
     await db.query(
-      `CREATE TABLE "${config.migrationsTable}" ( version TEXT NOT NULL )`
+      `CREATE TABLE ${quoteTable(
+        config.migrationsTable
+      )} ( version TEXT NOT NULL )`
     );
     console.log("Created versions table");
   } catch (err) {
@@ -104,6 +112,79 @@ const createSchemaMigrations = async (db, config) => {
     }
   }
 };
+const getFirstWordAndRest = (input) => {
+  const index = input.search(/(?=[A-Z])|[-_]/);
+  if (index !== -1) {
+    const restStart = input[index] === "-" || input[index] === "_" ? index + 1 : index;
+    const rest = input.slice(restStart);
+    return [input.slice(0, index), rest[0].toLowerCase() + rest.slice(1)];
+  } else {
+    return [input];
+  }
+};
+const getTextAfterRegExp = (input, regex, length) => {
+  let index = input.search(regex);
+  if (index === -1)
+    return;
+  if (input[index] === "-" || input[index] === "_")
+    index++;
+  index += length;
+  const start = input[index] == "-" || input[index] === "_" ? index + 1 : index;
+  const text = input.slice(start);
+  return text[0].toLowerCase() + text.slice(1);
+};
+const getTextAfterTo = (input) => {
+  return getTextAfterRegExp(input, /(To|-to|_to)[A-Z-_]/, 2);
+};
+const getTextAfterFrom = (input) => {
+  return getTextAfterRegExp(input, /(From|-from|_from)[A-Z-_]/, 4);
+};
+const getMigrationFiles = async (config, up) => {
+  const { migrationsPath } = config;
+  let files;
+  try {
+    files = await readdir(migrationsPath);
+  } catch (_) {
+    return [];
+  }
+  const sort = up ? sortAsc : sortDesc;
+  return sort(files).map((file) => {
+    if (!file.endsWith(".ts")) {
+      throw new Error(
+        `Only .ts files are supported for migration, received: ${file}`
+      );
+    }
+    const timestampMatch = file.match(/^(\d{14})\D/);
+    if (!timestampMatch) {
+      throw new Error(
+        `Migration file name should start with 14 digit version, received ${file}`
+      );
+    }
+    return {
+      path: path.join(migrationsPath, file),
+      version: timestampMatch[1]
+    };
+  });
+};
+const sortAsc = (arr) => arr.sort();
+const sortDesc = (arr) => arr.sort((a, b) => a > b ? -1 : 1);
+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(", ");
+};
+const quoteTable = (table) => {
+  const index = table.indexOf(".");
+  if (index !== -1) {
+    return `"${table.slice(0, index)}"."${table.slice(index + 1)}"`;
+  } else {
+    return `"${table}"`;
+  }
+};
 
 const execute = async (options, sql) => {
   const db = new Adapter(options);
@@ -182,9 +263,898 @@ const dropDb = async (arg) => {
   }
 };
 
+const generate = async (config, args) => {
+  const name = args[0];
+  if (!name)
+    throw new Error("Migration name is missing");
+  await mkdir(config.migrationsPath, { recursive: true });
+  const filePath = path.resolve(
+    config.migrationsPath,
+    `${makeFileTimeStamp()}_${name}.ts`
+  );
+  await writeFile(filePath, makeContent(name, args.slice(1)));
+  console.log(`Created ${filePath}`);
+};
+const makeFileTimeStamp = () => {
+  const now = new Date();
+  return [
+    now.getUTCFullYear(),
+    now.getUTCMonth() + 1,
+    now.getUTCDate(),
+    now.getUTCHours(),
+    now.getUTCMinutes(),
+    now.getUTCSeconds()
+  ].map((value) => value < 10 ? `0${value}` : value).join("");
+};
+const makeContent = (name, args) => {
+  let content = `import { change } from 'rake-db';
+
+change(async (db) => {`;
+  const [first, rest] = getFirstWordAndRest(name);
+  if (rest) {
+    if (first === "create" || first === "drop") {
+      content += `
+  await db.${first === "create" ? "createTable" : "dropTable"}('${rest}', (t) => ({`;
+      content += makeColumnsContent(args);
+      content += "\n  }));";
+    } else if (first === "change") {
+      content += `
+  await db.changeTable('${rest}', (t) => ({`;
+      content += "\n  }));";
+    } else if (first === "add" || first === "remove") {
+      const table = first === "add" ? getTextAfterTo(rest) : getTextAfterFrom(rest);
+      content += `
+  await db.changeTable(${table ? `'${table}'` : "tableName"}, (t) => ({`;
+      content += makeColumnsContent(args, first);
+      content += "\n  }));";
+    }
+  }
+  return content + "\n});\n";
+};
+const makeColumnsContent = (args, method) => {
+  let content = "";
+  const prepend = method ? `t.${method}(` : "";
+  const append = method ? ")" : "";
+  for (const arg of args) {
+    const [name, def] = arg.split(":");
+    if (!def) {
+      throw new Error(
+        `Column argument should be similar to name:type, name:type.method1.method2, name:type(arg).method(arg). Example: name:varchar(20).nullable. Received: ${arg}`
+      );
+    }
+    const methods = def.split(".").map((method2) => method2.endsWith(")") ? `.${method2}` : `.${method2}()`);
+    content += `
+    ${name}: ${prepend}t${methods.join("")}${append},`;
+  }
+  return content;
+};
+
+let currentMigration;
+let currentPromise;
+let currentUp = true;
 const change = (fn) => {
-  throw new Error("Database instance is not set");
+  if (!currentMigration)
+    throw new Error("Database instance is not set");
+  currentPromise = fn(currentMigration, currentUp);
+};
+const setCurrentMigration = (db) => {
+  currentMigration = db;
+};
+const setCurrentMigrationUp = (up) => {
+  currentUp = up;
+};
+const getCurrentPromise = () => currentPromise;
+
+var __defProp$2 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+const columnToSql = (key, item, { values }) => {
+  const line = [`"${key}" ${item.toSQL()}`];
+  if (item.data.compression) {
+    line.push(`COMPRESSION ${item.data.compression}`);
+  }
+  if (item.data.collate) {
+    line.push(`COLLATE ${quote(item.data.collate)}`);
+  }
+  if (item.isPrimaryKey) {
+    line.push("PRIMARY KEY");
+  } else if (!item.isNullable) {
+    line.push("NOT NULL");
+  }
+  if (item.data.default !== void 0) {
+    if (typeof item.data.default === "object" && item.data.default && isRaw(item.data.default)) {
+      line.push(`DEFAULT ${getRaw(item.data.default, values)}`);
+    } else {
+      line.push(`DEFAULT ${quote(item.data.default)}`);
+    }
+  }
+  const { foreignKey } = item.data;
+  if (foreignKey) {
+    const table = getForeignKeyTable(
+      "fn" in foreignKey ? foreignKey.fn : foreignKey.table
+    );
+    if (foreignKey.name) {
+      line.push(`CONSTRAINT "${foreignKey.name}"`);
+    }
+    line.push(referencesToSql(table, foreignKey.columns, foreignKey));
+  }
+  return line.join(" ");
+};
+const addColumnIndex = (indexes, key, item) => {
+  if (item.data) {
+    if (item.data.index) {
+      indexes.push({
+        columns: [__spreadProps$2(__spreadValues$2({}, item.data.index), { column: key })],
+        options: item.data.index
+      });
+    }
+  }
+};
+const addColumnComment = (comments, key, item) => {
+  if (item.data.comment) {
+    comments.push({ column: key, comment: item.data.comment });
+  }
+};
+const getForeignKeyTable = (fnOrTable) => {
+  if (typeof fnOrTable === "string") {
+    return fnOrTable;
+  }
+  const klass = fnOrTable();
+  return new klass().table;
+};
+const constraintToSql = (tableName, up, foreignKey) => {
+  const table = getForeignKeyTable(foreignKey.fnOrTable);
+  const constraintName = foreignKey.options.name || joinWords(tableName, "to", table);
+  if (!up) {
+    const { dropMode } = foreignKey.options;
+    return `CONSTRAINT "${constraintName}"${dropMode ? ` ${dropMode}` : ""}`;
+  }
+  return `CONSTRAINT "${constraintName}" FOREIGN KEY (${joinColumns(
+    foreignKey.columns
+  )}) ${referencesToSql(table, foreignKey.foreignColumns, foreignKey.options)}`;
+};
+const referencesToSql = (table, columns, foreignKey) => {
+  const sql = [
+    `REFERENCES ${quoteTable(table)}(${joinColumns(columns)})`
+  ];
+  if (foreignKey.match) {
+    sql.push(`MATCH ${foreignKey.match.toUpperCase()}`);
+  }
+  if (foreignKey.onDelete) {
+    sql.push(`ON DELETE ${foreignKey.onDelete.toUpperCase()}`);
+  }
+  if (foreignKey.onUpdate) {
+    sql.push(`ON UPDATE ${foreignKey.onUpdate.toUpperCase()}`);
+  }
+  return sql.join(" ");
+};
+const migrateIndexes = async (state, indexes, up) => {
+  for (const item of indexes) {
+    await migrateIndex(state, up, item);
+  }
+};
+const migrateIndex = (state, up, { columns, options }) => {
+  const indexName = options.name || joinWords(state.tableName, ...columns.map(({ column }) => column), "index");
+  if (!up) {
+    return state.migration.query(
+      `DROP INDEX "${indexName}"${options.dropMode ? ` ${options.dropMode}` : ""}`
+    );
+  }
+  const values = [];
+  const sql = ["CREATE"];
+  if (options.unique) {
+    sql.push("UNIQUE");
+  }
+  sql.push(`INDEX "${indexName}" ON ${quoteTable(state.tableName)}`);
+  if (options.using) {
+    sql.push(`USING ${options.using}`);
+  }
+  const columnsSql = [];
+  columns.forEach((column) => {
+    const columnSql = [
+      `"${column.column}"${column.expression ? `(${column.expression})` : ""}`
+    ];
+    if (column.collate) {
+      columnSql.push(`COLLATE '${column.collate}'`);
+    }
+    if (column.operator) {
+      columnSql.push(column.operator);
+    }
+    if (column.order) {
+      columnSql.push(column.order);
+    }
+    columnsSql.push(columnSql.join(" "));
+  });
+  sql.push(`(${columnsSql.join(", ")})`);
+  if (options.include) {
+    sql.push(
+      `INCLUDE (${toArray(options.include).map((column) => `"${column}"`).join(", ")})`
+    );
+  }
+  if (options.with) {
+    sql.push(`WITH (${options.with})`);
+  }
+  if (options.tablespace) {
+    sql.push(`TABLESPACE ${options.tablespace}`);
+  }
+  if (options.where) {
+    sql.push(
+      `WHERE ${typeof options.where === "object" && options.where && isRaw(options.where) ? getRaw(options.where, values) : options.where}`
+    );
+  }
+  return state.migration.query({ text: sql.join(" "), values });
+};
+const migrateComments = async (state, comments) => {
+  for (const { column, comment } of comments) {
+    await state.migration.query(
+      `COMMENT ON COLUMN ${quoteTable(state.tableName)}."${column}" IS ${quote(
+        comment
+      )}`
+    );
+  }
+};
+const primaryKeyToSql = (primaryKey) => {
+  var _a;
+  const name = (_a = primaryKey.options) == null ? void 0 : _a.name;
+  return `${name ? `CONSTRAINT "${name}" ` : ""}PRIMARY KEY (${joinColumns(
+    primaryKey.columns
+  )})`;
+};
+const getPrimaryKeysOfTable = async (db, tableName) => {
+  const { rows } = await db.query(
+    {
+      text: `SELECT
+  pg_attribute.attname AS name,
+  format_type(pg_attribute.atttypid, pg_attribute.atttypmod) AS type
+FROM pg_index, pg_class, pg_attribute, pg_namespace
+WHERE
+  pg_class.oid = $1::regclass AND
+  indrelid = pg_class.oid AND
+  nspname = 'public' AND
+  pg_class.relnamespace = pg_namespace.oid AND
+  pg_attribute.attrelid = pg_class.oid AND
+  pg_attribute.attnum = any(pg_index.indkey) AND
+  indisprimary`,
+      values: [tableName]
+    },
+    db.types,
+    void 0
+  );
+  return rows;
+};
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+class UnknownColumn extends ColumnType {
+  constructor(dataType) {
+    super();
+    this.dataType = dataType;
+    this.operators = Operators.any;
+  }
+}
+const createJoinTable = async (migration, up, tables, options, fn) => {
+  const tableName = options.tableName || joinWords(...tables);
+  if (!up) {
+    return createTable(migration, up, tableName, options, () => ({}));
+  }
+  const tablesWithPrimaryKeys = await Promise.all(
+    tables.map(async (table) => {
+      const primaryKeys = await getPrimaryKeysOfTable(migration, table).then(
+        (items) => items.map((item) => __spreadProps$1(__spreadValues$1({}, item), {
+          joinedName: joinWords(singular(table), item.name)
+        }))
+      );
+      if (!primaryKeys.length) {
+        throw new Error(
+          `Primary key for table ${quoteTable(table)} is not defined`
+        );
+      }
+      return [table, primaryKeys];
+    })
+  );
+  return createTable(migration, up, tableName, options, (t) => {
+    const result = {};
+    tablesWithPrimaryKeys.forEach(([table, primaryKeys]) => {
+      if (primaryKeys.length === 1) {
+        const [{ type, joinedName, name }] = primaryKeys;
+        const column = new UnknownColumn(type);
+        result[joinedName] = column.foreignKey(table, name);
+        return;
+      }
+      primaryKeys.forEach(({ joinedName, type }) => {
+        result[joinedName] = new UnknownColumn(type);
+      });
+      t.foreignKey(
+        primaryKeys.map((key) => key.joinedName),
+        table,
+        primaryKeys.map((key) => key.name)
+      );
+    });
+    if (fn) {
+      Object.assign(result, fn(t));
+    }
+    t.primaryKey(
+      tablesWithPrimaryKeys.flatMap(
+        ([, primaryKeys]) => primaryKeys.map((item) => item.joinedName)
+      )
+    );
+    return result;
+  });
+};
+const createTable = async (migration, up, tableName, options, fn) => {
+  const shape = getColumnTypes(columnTypes, fn);
+  if (!up) {
+    const { dropMode } = options;
+    await migration.query(
+      `DROP TABLE ${quoteTable(tableName)}${dropMode ? ` ${dropMode}` : ""}`
+    );
+    return;
+  }
+  const lines = [];
+  const state = {
+    migration,
+    tableName,
+    values: [],
+    indexes: [],
+    comments: []
+  };
+  for (const key in shape) {
+    const item = shape[key];
+    addColumnIndex(state.indexes, key, item);
+    addColumnComment(state.comments, key, item);
+    lines.push(`
+  ${columnToSql(key, item, state)}`);
+  }
+  const tableData = getTableData();
+  if (tableData.primaryKey) {
+    lines.push(`
+  ${primaryKeyToSql(tableData.primaryKey)}`);
+  }
+  tableData.foreignKeys.forEach((foreignKey) => {
+    lines.push(`
+  ${constraintToSql(state.tableName, up, foreignKey)}`);
+  });
+  await migration.query({
+    text: `CREATE TABLE ${quoteTable(tableName)} (${lines.join(",")}
+)`,
+    values: state.values
+  });
+  state.indexes.push(...tableData.indexes);
+  await migrateIndexes(state, state.indexes, up);
+  await migrateComments(state, state.comments);
+  if (options.comment) {
+    await migration.query(
+      `COMMENT ON TABLE ${quoteTable(tableName)} IS ${quote(options.comment)}`
+    );
+  }
+};
+
+const newChangeTableData = () => ({
+  add: [],
+  drop: []
+});
+let changeTableData = newChangeTableData();
+const resetChangeTableData = () => {
+  changeTableData = newChangeTableData();
+};
+function add(item, options) {
+  if (item instanceof ColumnType) {
+    return ["add", item, options];
+  } else if (item === emptyObject) {
+    changeTableData.add.push(getTableData());
+    resetTableData();
+    return emptyObject;
+  } else {
+    const result = {};
+    for (const key in item) {
+      result[key] = ["add", item[key], options];
+    }
+    return result;
+  }
+}
+const drop = (item, options) => {
+  if (item instanceof ColumnType) {
+    return ["drop", item, options];
+  } else if (item === emptyObject) {
+    changeTableData.drop.push(getTableData());
+    resetTableData();
+    return emptyObject;
+  } else {
+    const result = {};
+    for (const key in item) {
+      result[key] = [
+        "drop",
+        item[key],
+        options
+      ];
+    }
+    return result;
+  }
+};
+const tableChangeMethods = {
+  add,
+  drop,
+  change(from, to, options) {
+    return ["change", from, to, options];
+  },
+  default(value) {
+    return ["default", value];
+  },
+  nullable() {
+    return ["nullable", true];
+  },
+  nonNullable() {
+    return ["nullable", false];
+  },
+  comment(name) {
+    return ["comment", name];
+  },
+  rename(name) {
+    return ["rename", name];
+  }
+};
+const changeTable = async (migration, up, tableName, options, fn) => {
+  resetTableData();
+  resetChangeTableData();
+  const tableChanger = Object.create(columnTypes);
+  Object.assign(tableChanger, tableChangeMethods);
+  const changeData = (fn == null ? void 0 : fn(tableChanger)) || {};
+  const state = {
+    migration,
+    up,
+    tableName,
+    alterTable: [],
+    values: [],
+    indexes: [],
+    dropIndexes: [],
+    comments: []
+  };
+  if (options.comment !== void 0) {
+    await changeActions.tableComment(state, tableName, options.comment);
+  }
+  for (const key in changeData) {
+    const result = changeData[key];
+    if (Array.isArray(result)) {
+      const [action] = result;
+      if (action === "change") {
+        const [, from, to, options2] = result;
+        changeActions.change(state, up, key, from, to, options2);
+      } else if (action === "rename") {
+        const [, name] = result;
+        changeActions.rename(state, up, key, name);
+      } else {
+        const [action2, item, options2] = result;
+        changeActions[action2](state, up, key, item, options2);
+      }
+    }
+  }
+  changeTableData.add.forEach((tableData) => {
+    handleTableData(state, up, tableName, tableData);
+  });
+  changeTableData.drop.forEach((tableData) => {
+    handleTableData(state, !up, tableName, tableData);
+  });
+  if (state.alterTable.length) {
+    await migration.query(
+      `ALTER TABLE ${quoteTable(tableName)}
+  ${state.alterTable.join(",\n  ")}`
+    );
+  }
+  const createIndexes = up ? state.indexes : state.dropIndexes;
+  const dropIndexes = up ? state.dropIndexes : state.indexes;
+  await migrateIndexes(state, createIndexes, up);
+  await migrateIndexes(state, dropIndexes, !up);
+  await migrateComments(state, state.comments);
+};
+const changeActions = {
+  tableComment({ migration, up }, tableName, comment) {
+    let value;
+    if (up) {
+      value = Array.isArray(comment) ? comment[1] : comment;
+    } else {
+      value = Array.isArray(comment) ? comment[0] : null;
+    }
+    return migration.query(
+      `COMMENT ON TABLE ${quoteTable(tableName)} IS ${quote(value)}`
+    );
+  },
+  add(state, up, key, item, options) {
+    addColumnIndex(state[up ? "indexes" : "dropIndexes"], key, item);
+    if (up) {
+      addColumnComment(state.comments, key, item);
+    }
+    if (up) {
+      state.alterTable.push(`ADD COLUMN ${columnToSql(key, item, state)}`);
+    } else {
+      state.alterTable.push(
+        `DROP COLUMN "${key}"${(options == null ? void 0 : options.dropMode) ? ` ${options.dropMode}` : ""}`
+      );
+    }
+  },
+  drop(state, up, key, item, options) {
+    this.add(state, !up, key, item, options);
+  },
+  change(state, up, key, first, second, options) {
+    const [fromItem, toItem] = up ? [first, second] : [second, first];
+    const from = getChangeProperties(fromItem);
+    const to = getChangeProperties(toItem);
+    if (from.type !== to.type || from.collate !== to.collate) {
+      const using = up ? options == null ? void 0 : options.usingUp : options == null ? void 0 : options.usingDown;
+      state.alterTable.push(
+        `ALTER COLUMN "${key}" TYPE ${to.type}${to.collate ? ` COLLATE ${quote(to.collate)}` : ""}${using ? ` USING ${getRaw(using, state.values)}` : ""}`
+      );
+    }
+    if (from.default !== to.default) {
+      const value = getRawOrValue(to.default, state.values);
+      const expr = value === void 0 ? `DROP DEFAULT` : `SET DEFAULT ${value}`;
+      state.alterTable.push(`ALTER COLUMN "${key}" ${expr}`);
+    }
+    if (from.nullable !== to.nullable) {
+      state.alterTable.push(
+        `ALTER COLUMN "${key}" ${to.nullable ? "DROP" : "SET"} NOT NULL`
+      );
+    }
+    if (from.comment !== to.comment) {
+      state.comments.push({ column: key, comment: to.comment || null });
+    }
+  },
+  rename(state, up, key, name) {
+    const [from, to] = up ? [key, name] : [name, key];
+    state.alterTable.push(`RENAME COLUMN "${from}" TO "${to}"`);
+  }
+};
+const getChangeProperties = (item) => {
+  if (item instanceof ColumnType) {
+    return {
+      type: item.toSQL(),
+      collate: item.data.collate,
+      default: item.data.default,
+      nullable: item.isNullable,
+      comment: item.data.comment
+    };
+  } else {
+    return {
+      type: void 0,
+      collate: void 0,
+      default: item[0] === "default" ? item[1] : void 0,
+      nullable: item[0] === "nullable" ? item[1] : void 0,
+      comment: item[0] === "comment" ? item[1] : void 0
+    };
+  }
+};
+const handleTableData = (state, up, tableName, tableData) => {
+  var _a;
+  if (tableData.primaryKey) {
+    if (up) {
+      state.alterTable.push(`ADD ${primaryKeyToSql(tableData.primaryKey)}`);
+    } else {
+      const name = ((_a = tableData.primaryKey.options) == null ? void 0 : _a.name) || `${tableName}_pkey`;
+      state.alterTable.push(`DROP CONSTRAINT "${name}"`);
+    }
+  }
+  if (tableData.indexes.length) {
+    state[up ? "indexes" : "dropIndexes"].push(...tableData.indexes);
+  }
+  if (tableData.foreignKeys.length) {
+    tableData.foreignKeys.forEach((foreignKey) => {
+      const action = up ? "ADD" : "DROP";
+      state.alterTable.push(
+        `
+  ${action} ${constraintToSql(state.tableName, up, foreignKey)}`
+      );
+    });
+  }
+};
+const getRawOrValue = (item, values) => {
+  return typeof item === "object" && item && isRaw(item) ? getRaw(item, values) : quote(item);
+};
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+class Migration extends TransactionAdapter {
+  constructor(tx, up, options) {
+    super(tx.pool, tx.client, tx.types);
+    this.up = up;
+    this.log = logParamToLogObject(options.logger || console, options.log);
+  }
+  async query(query, types = this.types, log = this.log) {
+    return wrapWithLog(log, query, () => super.query(query, types));
+  }
+  async arrays(query, types = this.types, log = this.log) {
+    return wrapWithLog(log, query, () => super.arrays(query, types));
+  }
+  createTable(tableName, cbOrOptions, cb) {
+    const options = typeof cbOrOptions === "function" ? {} : cbOrOptions;
+    const fn = cb || cbOrOptions;
+    return createTable(this, this.up, tableName, options, fn);
+  }
+  dropTable(tableName, cbOrOptions, cb) {
+    const options = typeof cbOrOptions === "function" ? {} : cbOrOptions;
+    const fn = cb || cbOrOptions;
+    return createTable(this, !this.up, tableName, options, fn);
+  }
+  async createJoinTable(tables, cbOrOptions, cb) {
+    const options = typeof cbOrOptions === "function" ? {} : cbOrOptions || {};
+    const fn = cb || cbOrOptions;
+    return createJoinTable(this, this.up, tables, options, fn);
+  }
+  async dropJoinTable(tables, cbOrOptions, cb) {
+    const options = typeof cbOrOptions === "function" ? {} : cbOrOptions || {};
+    const fn = cb || cbOrOptions;
+    return createJoinTable(this, !this.up, tables, options, fn);
+  }
+  changeTable(tableName, cbOrOptions, cb) {
+    const [fn, options] = typeof cbOrOptions === "function" ? [cbOrOptions, {}] : [cb, cbOrOptions];
+    return changeTable(this, this.up, tableName, options, fn);
+  }
+  async renameTable(from, to) {
+    const [table, newName] = this.up ? [from, to] : [to, from];
+    await this.query(`ALTER TABLE ${quoteTable(table)} RENAME TO "${newName}"`);
+  }
+  addColumn(tableName, columnName, fn) {
+    return addColumn(this, this.up, tableName, columnName, fn);
+  }
+  dropColumn(tableName, columnName, fn) {
+    return addColumn(this, !this.up, tableName, columnName, fn);
+  }
+  addIndex(tableName, columns, options) {
+    return addIndex(this, this.up, tableName, columns, options);
+  }
+  dropIndex(tableName, columns, options) {
+    return addIndex(this, !this.up, tableName, columns, options);
+  }
+  addForeignKey(tableName, columns, foreignTable, foreignColumns, options) {
+    return addForeignKey(
+      this,
+      this.up,
+      tableName,
+      columns,
+      foreignTable,
+      foreignColumns,
+      options
+    );
+  }
+  dropForeignKey(tableName, columns, foreignTable, foreignColumns, options) {
+    return addForeignKey(
+      this,
+      !this.up,
+      tableName,
+      columns,
+      foreignTable,
+      foreignColumns,
+      options
+    );
+  }
+  addPrimaryKey(tableName, columns, options) {
+    return addPrimaryKey(this, this.up, tableName, columns, options);
+  }
+  dropPrimaryKey(tableName, columns, options) {
+    return addPrimaryKey(this, !this.up, tableName, columns, options);
+  }
+  renameColumn(tableName, from, to) {
+    return this.changeTable(tableName, (t) => ({
+      [from]: t.rename(to)
+    }));
+  }
+  createSchema(schemaName) {
+    return createSchema(this, this.up, schemaName);
+  }
+  dropSchema(schemaName) {
+    return createSchema(this, !this.up, schemaName);
+  }
+  createExtension(name, options = {}) {
+    return createExtension(this, this.up, name, __spreadProps(__spreadValues({}, options), {
+      checkExists: options.ifNotExists
+    }));
+  }
+  dropExtension(name, options = {}) {
+    return createExtension(this, !this.up, name, __spreadProps(__spreadValues({}, options), {
+      checkExists: options.ifExists
+    }));
+  }
+  async tableExists(tableName) {
+    return queryExists(this, {
+      text: `SELECT 1 FROM "information_schema"."tables" WHERE "table_name" = $1`,
+      values: [tableName]
+    });
+  }
+  async columnExists(tableName, columnName) {
+    return queryExists(this, {
+      text: `SELECT 1 FROM "information_schema"."columns" WHERE "table_name" = $1 AND "column_name" = $2`,
+      values: [tableName, columnName]
+    });
+  }
+  async constraintExists(constraintName) {
+    return queryExists(this, {
+      text: `SELECT 1 FROM "information_schema"."table_constraints" WHERE "constraint_name" = $1`,
+      values: [constraintName]
+    });
+  }
+}
+const wrapWithLog = async (log, query, fn) => {
+  if (!log) {
+    return fn();
+  } else {
+    const sql = typeof query === "string" ? { text: query, values: [] } : query.values ? query : __spreadProps(__spreadValues({}, query), { values: [] });
+    const logData = log.beforeQuery(sql);
+    try {
+      const result = await fn();
+      log.afterQuery(sql, logData);
+      return result;
+    } catch (err) {
+      log.onError(err, sql, logData);
+      throw err;
+    }
+  }
+};
+const addColumn = (migration, up, tableName, columnName, fn) => {
+  return changeTable(migration, up, tableName, {}, (t) => ({
+    [columnName]: t.add(fn(t))
+  }));
+};
+const addIndex = (migration, up, tableName, columns, options) => {
+  return changeTable(migration, up, tableName, {}, (t) => __spreadValues({}, t.add(t.index(columns, options))));
+};
+const addForeignKey = (migration, up, tableName, columns, foreignTable, foreignColumns, options) => {
+  return changeTable(migration, up, tableName, {}, (t) => __spreadValues({}, t.add(t.foreignKey(columns, foreignTable, foreignColumns, options))));
+};
+const addPrimaryKey = (migration, up, tableName, columns, options) => {
+  return changeTable(migration, up, tableName, {}, (t) => __spreadValues({}, t.add(t.primaryKey(columns, options))));
+};
+const createSchema = (migration, up, schemaName) => {
+  if (up) {
+    return migration.query(`CREATE SCHEMA "${schemaName}"`);
+  } else {
+    return migration.query(`DROP SCHEMA "${schemaName}"`);
+  }
+};
+const createExtension = (migration, up, name, options) => {
+  if (!up) {
+    return migration.query(
+      `DROP EXTENSION${options.checkExists ? " IF EXISTS" : ""} "${name}"${options.cascade ? " CASCADE" : ""}`
+    );
+  }
+  return migration.query(
+    `CREATE EXTENSION${options.checkExists ? " IF NOT EXISTS" : ""} "${name}"${options.schema ? ` SCHEMA "${options.schema}"` : ""}${options.version ? ` VERSION '${options.version}'` : ""}${options.cascade ? " CASCADE" : ""}`
+  );
+};
+const queryExists = (db, sql) => {
+  return db.query(sql).then(({ rowCount }) => rowCount > 0);
+};
+
+const migrateOrRollback = async (options, config, args, up) => {
+  var _a;
+  const files = await getMigrationFiles(config, up);
+  const argCount = parseInt(args[0]);
+  let count = isNaN(argCount) ? up ? Infinity : 1 : argCount;
+  for (const opts of toArray(options)) {
+    const db = new Adapter(opts);
+    const migratedVersions = await getMigratedVersionsMap(db, config);
+    try {
+      for (const file of files) {
+        if (up && migratedVersions[file.version] || !up && !migratedVersions[file.version]) {
+          continue;
+        }
+        if (count-- <= 0)
+          break;
+        await processMigration(db, up, file, config);
+        (_a = config.logger) == null ? void 0 : _a.log(`${file.path} ${up ? "migrated" : "rolled back"}`);
+      }
+    } finally {
+      await db.destroy();
+    }
+  }
+};
+const processMigration = async (db, up, file, config) => {
+  await db.transaction(async (tx) => {
+    const db2 = new Migration(tx, up, config);
+    setCurrentMigration(db2);
+    setCurrentMigrationUp(up);
+    config.requireTs(file.path);
+    await getCurrentPromise();
+    await (up ? saveMigratedVersion : removeMigratedVersion)(
+      db2,
+      file.version,
+      config
+    );
+  });
+};
+const saveMigratedVersion = async (db, version, config) => {
+  await db.query(
+    `INSERT INTO ${quoteTable(config.migrationsTable)} VALUES ('${version}')`
+  );
+};
+const removeMigratedVersion = async (db, version, config) => {
+  await db.query(
+    `DELETE FROM ${quoteTable(
+      config.migrationsTable
+    )} WHERE version = '${version}'`
+  );
+};
+const getMigratedVersionsMap = async (db, config) => {
+  try {
+    const result = await db.arrays(
+      `SELECT * FROM ${quoteTable(config.migrationsTable)}`
+    );
+    return Object.fromEntries(result.rows.map((row) => [row[0], true]));
+  } catch (err) {
+    if (err.code === "42P01") {
+      await createSchemaMigrations(db, config);
+      return {};
+    }
+    throw err;
+  }
+};
+const migrate = (options, config, args) => migrateOrRollback(options, config, args, true);
+const rollback = (options, config, args) => migrateOrRollback(options, config, args, false);
+
+const rakeDb = async (options, partialConfig = {}, args = process.argv.slice(2)) => {
+  const config = getMigrationConfigWithDefaults(partialConfig);
+  const command = args[0].split(":")[0];
+  if (command === "create") {
+    await createDb(options, config);
+  } else if (command === "drop") {
+    await dropDb(options);
+  } else if (command === "migrate") {
+    await migrate(options, config, args.slice(1));
+  } else if (command === "rollback") {
+    await rollback(options, config, args.slice(1));
+  } else if (command === "g" || command === "generate") {
+    await generate(config, args.slice(1));
+  } else {
+    console.log(`Usage: rake-db [command] [arguments]`);
+  }
 };
 
-export { change, createDb, dropDb };
+export { Migration, change, createDb, dropDb, generate, migrate, rakeDb, rollback };
 //# sourceMappingURL=index.esm.js.map