rake-db 2.17.8 → 2.18.0

package/dist/index.js

@@ -5,8 +5,6 @@ var orchidCore = require('orchid-core');
 var path = require('path');
 var node_url = require('node:url');
 var fs = require('fs/promises');
-var prompts = require('prompts');
-var rakeDb$1 = require('rake-db');
 
 const getFirstWordAndRest = (input) => {
   const index = input.search(/(?=[A-Z])|[-_]/);
@@ -35,6 +33,12 @@ const getTextAfterTo = (input) => {
 const getTextAfterFrom = (input) => {
   return getTextAfterRegExp(input, /(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(", ");
 };
@@ -50,11 +54,14 @@ const getSchemaAndTableFromName = (name) => {
 const quoteNameFromString = (string) => {
   return quoteTable(...getSchemaAndTableFromName(string));
 };
-const quoteSchemaTable = ({
+const quoteSchemaTable = (arg) => {
+  return orchidCore.singleQuote(concatSchemaAndName(arg));
+};
+const concatSchemaAndName = ({
   schema,
   name
 }) => {
-  return orchidCore.singleQuote(schema ? `${schema}.${name}` : name);
+  return schema ? `${schema}.${name}` : name;
 };
 const makePopulateEnumQuery = (item) => {
   const [schema, name] = getSchemaAndTableFromName(item.enumName);
@@ -66,13 +73,18 @@ const makePopulateEnumQuery = (item) => {
   };
 };
 const begin = {
-  text: "BEGIN",
-  values: orchidCore.emptyArray
+  text: "BEGIN"
 };
 const transaction = (adapter, fn) => {
   return adapter.transaction(begin, 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 = () => {
@@ -81,28 +93,28 @@ const clearChanges = () => {
 const getCurrentChanges = () => currentChanges;
 const pushChange = (fn) => currentChanges.push(fn);
 
-var __defProp$a = Object.defineProperty;
+var __defProp$9 = Object.defineProperty;
 var __defProps$7 = Object.defineProperties;
 var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
-var __hasOwnProp$a = Object.prototype.hasOwnProperty;
-var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$a = (a, b) => {
+var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
+var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
+var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$9 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$a.call(b, prop))
-      __defNormalProp$a(a, prop, b[prop]);
-  if (__getOwnPropSymbols$a)
-    for (var prop of __getOwnPropSymbols$a(b)) {
-      if (__propIsEnum$a.call(b, prop))
-        __defNormalProp$a(a, prop, b[prop]);
+    if (__hasOwnProp$9.call(b, prop))
+      __defNormalProp$9(a, prop, b[prop]);
+  if (__getOwnPropSymbols$9)
+    for (var prop of __getOwnPropSymbols$9(b)) {
+      if (__propIsEnum$9.call(b, prop))
+        __defNormalProp$9(a, prop, b[prop]);
     }
   return a;
 };
 var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
 const versionToString = (config, version) => config.migrationId === "serial" ? `${version}`.padStart(4, "0") : `${version}`;
 const columnTypeToSql = (item) => {
-  return item.data.isOfCustomType ? `"${item.toSQL()}"` : item.toSQL();
+  return item.data.isOfCustomType ? quoteNameFromString(item.toSQL()) : item.toSQL();
 };
 const getColumnName = (item, key, snakeCase) => {
   return item.data.name || (snakeCase ? orchidCore.toSnakeCase(key) : key);
@@ -122,13 +134,16 @@ const columnToSql = (name, item, values, hasMultiplePrimaryKeys, snakeCase) => {
       `GENERATED ALWAYS AS (${item.data.generated.toSQL({ values })}) STORED`
     );
   }
-  if (item.data.isPrimaryKey && !hasMultiplePrimaryKeys) {
+  if (item.data.primaryKey && !hasMultiplePrimaryKeys) {
+    if (item.data.primaryKey !== true) {
+      line.push(`CONSTRAINT "${item.data.primaryKey}"`);
+    }
     line.push("PRIMARY KEY");
   } else if (!item.data.isNullable) {
     line.push("NOT NULL");
   }
   if (item.data.check) {
-    line.push(checkToSql(item.data.check, values));
+    line.push(checkToSql(item.data.check.sql, values));
   }
   const def = encodeColumnDefault(item.data.default, values, item);
   if (def !== null)
@@ -172,14 +187,14 @@ const sequenceOptionsToSql = (item) => {
   const line = [];
   if (item.dataType)
     line.push(`AS ${item.dataType}`);
-  if (item.incrementBy !== void 0)
-    line.push(`INCREMENT BY ${item.incrementBy}`);
+  if (item.increment !== void 0)
+    line.push(`INCREMENT BY ${item.increment}`);
   if (item.min !== void 0)
     line.push(`MINVALUE ${item.min}`);
   if (item.max !== void 0)
     line.push(`MAXVALUE ${item.max}`);
-  if (item.startWith !== void 0)
-    line.push(`START WITH ${item.startWith}`);
+  if (item.start !== void 0)
+    line.push(`START WITH ${item.start}`);
   if (item.cache !== void 0)
     line.push(`CACHE ${item.cache}`);
   if (item.cycle)
@@ -194,7 +209,7 @@ const addColumnIndex = (indexes, name, item) => {
   if (item.data.indexes) {
     indexes.push(
       ...item.data.indexes.map((index) => ({
-        columns: [__spreadProps$7(__spreadValues$a({}, index), { column: name })],
+        columns: [__spreadProps$7(__spreadValues$9({}, index), { column: name })],
         options: index
       }))
     );
@@ -217,6 +232,8 @@ const getConstraintName = (table, constraint) => {
     return `${table}_${constraint.references.columns.join("_")}_fkey`;
   if (constraint.check)
     return `${table}_check`;
+  if (constraint.identity)
+    return `${table}_identity`;
   return `${table}_constraint`;
 };
 const constraintToSql = ({ name }, up, constraint, values, snakeCase) => {
@@ -263,12 +280,7 @@ const referencesToSql = (references, snakeCase) => {
   return sql.join(" ");
 };
 const getIndexName = (table, columns) => {
-  return `${table}_${columns.map(
-    (it) => {
-      var _a;
-      return "column" in it ? it.column : ((_a = it.expression.match(/\w+/g)) == null ? void 0 : _a.join("_")) || "expression";
-    }
-  ).join("_")}_idx`;
+  return `${table}_${columns.map((it) => "column" in it ? it.column : "expression").join("_")}_idx`;
 };
 const indexesToQuery = (up, { schema, name }, indexes, language) => {
   return indexes.map(({ columns, options }) => {
@@ -285,12 +297,12 @@ const indexesToQuery = (up, { schema, name }, indexes, language) => {
       sql.push("UNIQUE");
     }
     sql.push(`INDEX "${indexName}" ON ${quoteTable(schema, name)}`);
-    const using = options.using || options.tsVector && "GIN";
-    if (using) {
-      sql.push(`USING ${using}`);
+    const u = options.using || options.tsVector && "GIN";
+    if (u) {
+      sql.push(`USING ${u}`);
     }
     const columnsSql = [];
-    const lang = options.tsVector && options.languageColumn ? `"${options.languageColumn}"` : options.language ? typeof options.language === "string" ? `'${options.language}'` : options.language.toSQL({ values }) : `'${language || "english"}'`;
+    const lang = options.tsVector && options.languageColumn ? `"${options.languageColumn}"` : options.language ? `'${options.language}'` : `'${language || "english"}'`;
     let hasWeight = options.tsVector && columns.some((column) => !!column.weight);
     for (const column of columns) {
       const columnSql = [
@@ -315,11 +327,13 @@ const indexesToQuery = (up, { schema, name }, indexes, language) => {
       }
       columnsSql.push(sql2);
     }
-    let columnList = columnsSql.join(hasWeight ? " || " : ", ");
-    if (!hasWeight && options.tsVector) {
-      if (columnsSql.length > 1)
-        columnList = `concat_ws(' ', ${columnList})`;
-      columnList = `to_tsvector(${lang}, ${columnList})`;
+    let columnList;
+    if (hasWeight) {
+      columnList = `(${columnsSql.join(" || ")})`;
+    } else if (options.tsVector) {
+      columnList = `to_tsvector(${lang}, ${columnsSql.join(" || ' ' || ")})`;
+    } else {
+      columnList = columnsSql.join(", ");
     }
     sql.push(`(${columnList})`);
     if (options.include) {
@@ -376,38 +390,38 @@ class RakeDbError extends Error {
 class NoPrimaryKey extends RakeDbError {
 }
 
-var __defProp$9 = Object.defineProperty;
+var __defProp$8 = Object.defineProperty;
 var __defProps$6 = Object.defineProperties;
 var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
-var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
-var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$9 = (a, b) => {
+var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
+var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
+var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$8 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$9.call(b, prop))
-      __defNormalProp$9(a, prop, b[prop]);
-  if (__getOwnPropSymbols$9)
-    for (var prop of __getOwnPropSymbols$9(b)) {
-      if (__propIsEnum$9.call(b, prop))
-        __defNormalProp$9(a, prop, b[prop]);
+    if (__hasOwnProp$8.call(b, prop))
+      __defNormalProp$8(a, prop, b[prop]);
+  if (__getOwnPropSymbols$8)
+    for (var prop of __getOwnPropSymbols$8(b)) {
+      if (__propIsEnum$8.call(b, prop))
+        __defNormalProp$8(a, prop, b[prop]);
     }
   return a;
 };
 var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
-var __objRest$1 = (source, exclude) => {
+var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
-    if (__hasOwnProp$9.call(source, prop) && exclude.indexOf(prop) < 0)
+    if (__hasOwnProp$8.call(source, prop) && exclude.indexOf(prop) < 0)
       target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols$9)
-    for (var prop of __getOwnPropSymbols$9(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum$9.call(source, prop))
+  if (source != null && __getOwnPropSymbols$8)
+    for (var prop of __getOwnPropSymbols$8(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$8.call(source, prop))
         target[prop] = source[prop];
     }
   return target;
 };
-const createTable$1 = async (migration, up, tableName, options, fn) => {
+const createTable = async (migration, up, tableName, options, fn) => {
   var _a;
   const snakeCase = "snakeCase" in options ? options.snakeCase : migration.options.snakeCase;
   const language = "language" in options ? options.language : migration.options.language;
@@ -416,8 +430,19 @@ const createTable$1 = async (migration, up, tableName, options, fn) => {
     tableMethods
   );
   types[orchidCore.snakeCaseKey] = snakeCase;
-  const shape = !fn ? orchidCore.emptyObject : pqb.getColumnTypes(types, fn, (_a = migration.options.baseTable) == null ? void 0 : _a.nowSQL, language);
-  const tableData = pqb.getTableData();
+  let shape;
+  let tableData;
+  if (fn) {
+    shape = pqb.getColumnTypes(
+      types,
+      fn,
+      (_a = migration.options.baseTable) == null ? void 0 : _a.nowSQL,
+      language
+    );
+    tableData = pqb.getTableData();
+  } else {
+    shape = tableData = orchidCore.emptyObject;
+  }
   const ast = makeAst$2(
     up,
     tableName,
@@ -429,11 +454,10 @@ const createTable$1 = async (migration, up, tableName, options, fn) => {
   fn && validatePrimaryKey(ast);
   const queries = astToQueries$1(ast, snakeCase, language);
   for (const _b of queries) {
-    const _c = _b, { then } = _c, query = __objRest$1(_c, ["then"]);
+    const _c = _b, { then } = _c, query = __objRest(_c, ["then"]);
     const result = await migration.adapter.arrays(query);
     then == null ? void 0 : then(result);
   }
-  migration.migratedAsts.push(ast);
   let table;
   return {
     get table() {
@@ -448,20 +472,20 @@ const makeAst$2 = (up, tableName, shape, tableData, options, noPrimaryKey) => {
   const shapePKeys = [];
   for (const key in shape) {
     const column = shape[key];
-    if (column.data.isPrimaryKey) {
+    if (column.data.primaryKey) {
       shapePKeys.push(key);
     }
   }
   const { primaryKey } = tableData;
   const [schema, table] = getSchemaAndTableFromName(tableName);
-  return __spreadProps$6(__spreadValues$9(__spreadProps$6(__spreadValues$9({
+  return __spreadProps$6(__spreadValues$8(__spreadProps$6(__spreadValues$8({
     type: "table",
     action: up ? "create" : "drop",
     schema,
     name: table,
     shape
   }, tableData), {
-    primaryKey: shapePKeys.length <= 1 ? primaryKey : primaryKey ? __spreadProps$6(__spreadValues$9({}, primaryKey), { columns: [...shapePKeys, ...primaryKey.columns] }) : { columns: shapePKeys }
+    primaryKey: shapePKeys.length <= 1 ? primaryKey : primaryKey ? __spreadProps$6(__spreadValues$8({}, primaryKey), { columns: [...shapePKeys, ...primaryKey.columns] }) : { columns: shapePKeys }
   }), options), {
     noPrimaryKey: options.noPrimaryKey ? "ignore" : noPrimaryKey || "error"
   });
@@ -472,7 +496,7 @@ const validatePrimaryKey = (ast) => {
     let hasPrimaryKey = !!((_b = (_a = ast.primaryKey) == null ? void 0 : _a.columns) == null ? void 0 : _b.length);
     if (!hasPrimaryKey) {
       for (const key in ast.shape) {
-        if (ast.shape[key].data.isPrimaryKey) {
+        if (ast.shape[key].data.primaryKey) {
           hasPrimaryKey = true;
           break;
         }
@@ -538,8 +562,8 @@ const astToQueries$1 = (ast, snakeCase, language) => {
   ${constraintToSql(
         ast,
         true,
-        __spreadProps$6(__spreadValues$9({}, item), {
-          references: item.references ? __spreadProps$6(__spreadValues$9({}, item.references), {
+        __spreadProps$6(__spreadValues$8({}, item), {
+          references: item.references ? __spreadProps$6(__spreadValues$8({}, item.references), {
             columns: item.references.columns.map(
               (column) => getColumnName(shape[column], column, snakeCase)
             )
@@ -551,8 +575,8 @@ const astToQueries$1 = (ast, snakeCase, language) => {
     );
   });
   indexes.push(
-    ...((_b = ast.indexes) == null ? void 0 : _b.map((index) => __spreadProps$6(__spreadValues$9({}, index), {
-      columns: index.columns.map((item) => __spreadValues$9(__spreadValues$9({}, item), "column" in item ? {
+    ...((_b = ast.indexes) == null ? void 0 : _b.map((index) => __spreadProps$6(__spreadValues$8({}, index), {
+      columns: index.columns.map((item) => __spreadValues$8(__spreadValues$8({}, item), "column" in item ? {
         column: getColumnName(shape[item.column], item.column, snakeCase)
       } : {}))
     }))) || []
@@ -574,21 +598,21 @@ const astToQueries$1 = (ast, snakeCase, language) => {
   return queries;
 };
 
-var __defProp$8 = Object.defineProperty;
+var __defProp$7 = Object.defineProperty;
 var __defProps$5 = Object.defineProperties;
 var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
-var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
-var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$8 = (a, b) => {
+var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
+var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
+var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$7 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$8.call(b, prop))
-      __defNormalProp$8(a, prop, b[prop]);
-  if (__getOwnPropSymbols$8)
-    for (var prop of __getOwnPropSymbols$8(b)) {
-      if (__propIsEnum$8.call(b, prop))
-        __defNormalProp$8(a, prop, b[prop]);
+    if (__hasOwnProp$7.call(b, prop))
+      __defNormalProp$7(a, prop, b[prop]);
+  if (__getOwnPropSymbols$7)
+    for (var prop of __getOwnPropSymbols$7(b)) {
+      if (__propIsEnum$7.call(b, prop))
+        __defNormalProp$7(a, prop, b[prop]);
     }
   return a;
 };
@@ -608,16 +632,21 @@ const mergeTableData = (a, b) => {
     } else {
       a.primaryKey = {
         columns: [...a.primaryKey.columns, ...b.primaryKey.columns],
-        options: __spreadValues$8(__spreadValues$8({}, a.primaryKey.options), b.primaryKey.options)
+        options: __spreadValues$7(__spreadValues$7({}, a.primaryKey.options), b.primaryKey.options)
       };
     }
   }
   a.indexes = [...a.indexes || [], ...b.indexes || []];
   a.constraints = [...a.constraints || [], ...b.constraints || []];
 };
+const addOrDropChanges = [];
 function add(item, options) {
   if (item instanceof pqb.ColumnType) {
-    return addOrDrop("add", item, options);
+    const result = addOrDrop("add", item, options);
+    if (result.type === "change")
+      return result;
+    addOrDropChanges.push(result);
+    return addOrDropChanges.length - 1;
   } else if (item === orchidCore.emptyObject) {
     mergeTableData(changeTableData.add, pqb.getTableData());
     pqb.resetTableData();
@@ -636,7 +665,11 @@ function add(item, options) {
 }
 const drop = function(item, options) {
   if (item instanceof pqb.ColumnType) {
-    return addOrDrop("drop", item, options);
+    const result = addOrDrop("drop", item, options);
+    if (result.type === "change")
+      return result;
+    addOrDropChanges.push(result);
+    return addOrDropChanges.length - 1;
   } else if (item === orchidCore.emptyObject) {
     mergeTableData(changeTableData.drop, pqb.getTableData());
     pqb.resetTableData();
@@ -671,7 +704,7 @@ const addOrDrop = (type, item, options) => {
         check: item.data.check
       }
     });
-    return __spreadValues$8({
+    return __spreadValues$7({
       type: "change",
       from: type === "add" ? empty : add2,
       to: type === "add" ? add2 : empty
@@ -689,19 +722,19 @@ const columnTypeToColumnChange = (item) => {
     if (foreignKeys == null ? void 0 : foreignKeys.some((it) => "fn" in it)) {
       throw new Error("Callback in foreignKey is not allowed in migration");
     }
-    return __spreadProps$5(__spreadValues$8({
+    return __spreadProps$5(__spreadValues$7({
       column: item,
       type: item.toSQL(),
-      nullable: item.data.isNullable,
-      primaryKey: item.data.isPrimaryKey
+      nullable: item.data.isNullable
     }, item.data), {
+      primaryKey: item.data.primaryKey === void 0 ? void 0 : true,
       foreignKeys
     });
   }
   return item.to;
 };
 const nameKey = Symbol("name");
-const tableChangeMethods = __spreadProps$5(__spreadValues$8({}, tableMethods), {
+const tableChangeMethods = __spreadProps$5(__spreadValues$7({}, tableMethods), {
   name(name) {
     orchidCore.setCurrentColumnName(name);
     const types = Object.create(this);
@@ -710,13 +743,14 @@ const tableChangeMethods = __spreadProps$5(__spreadValues$8({}, tableMethods), {
   },
   add,
   drop,
-  change(from, to, options) {
-    return __spreadValues$8({
+  change(from, to, using) {
+    return {
       type: "change",
-      name: this[nameKey],
+      name: orchidCore.consumeColumnName(),
       from: columnTypeToColumnChange(from),
-      to: columnTypeToColumnChange(to)
-    }, options);
+      to: columnTypeToColumnChange(to),
+      using
+    };
   },
   default(value) {
     return { type: "change", from: { default: null }, to: { default: value } };
@@ -754,6 +788,7 @@ const changeTable = async (migration, up, tableName, options, fn) => {
   );
   Object.assign(tableChanger, tableChangeMethods);
   tableChanger[orchidCore.snakeCaseKey] = snakeCase;
+  addOrDropChanges.length = 0;
   const changeData = (fn == null ? void 0 : fn(tableChanger)) || {};
   const ast = makeAst$1(up, tableName, changeData, changeTableData, options);
   const queries = astToQueries(ast, snakeCase, language);
@@ -761,30 +796,54 @@ const changeTable = async (migration, up, tableName, options, fn) => {
     const result = await migration.adapter.arrays(query);
     (_a = query.then) == null ? void 0 : _a.call(query, result);
   }
-  migration.migratedAsts.push(ast);
 };
 const makeAst$1 = (up, name, changeData, changeTableData2, options) => {
   const { comment } = options;
   const shape = {};
+  const consumedChanges = {};
   for (const key in changeData) {
     let item = changeData[key];
-    if (item instanceof orchidCore.ColumnTypeBase) {
-      item = add(item);
+    if (typeof item === "number") {
+      consumedChanges[item] = true;
+      item = addOrDropChanges[item];
+    } else if (item instanceof pqb.ColumnType) {
+      item = addOrDrop("add", item);
     }
     if ("type" in item) {
       if (up) {
-        shape[key] = item.type === "change" && item.usingUp ? __spreadProps$5(__spreadValues$8({}, item), { using: item.usingUp }) : item;
+        shape[key] = item;
       } else {
         if (item.type === "rename") {
-          shape[item.name] = __spreadProps$5(__spreadValues$8({}, item), { name: key });
+          shape[item.name] = __spreadProps$5(__spreadValues$7({}, item), { name: key });
         } else {
-          shape[key] = item.type === "add" ? __spreadProps$5(__spreadValues$8({}, item), { type: "drop" }) : item.type === "drop" ? __spreadProps$5(__spreadValues$8({}, item), { type: "add" }) : item.type === "change" ? __spreadProps$5(__spreadValues$8({}, item), { from: item.to, to: item.from, using: item.usingDown }) : item;
+          shape[key] = item.type === "add" ? __spreadProps$5(__spreadValues$7({}, item), { type: "drop" }) : item.type === "drop" ? __spreadProps$5(__spreadValues$7({}, item), { type: "add" }) : item.type === "change" ? __spreadProps$5(__spreadValues$7({}, item), {
+            from: item.to,
+            to: item.from,
+            using: item.using && {
+              usingUp: item.using.usingDown,
+              usingDown: item.using.usingUp
+            }
+          }) : item;
         }
       }
     }
   }
+  for (let i = 0; i < addOrDropChanges.length; i++) {
+    if (consumedChanges[i])
+      continue;
+    const change = addOrDropChanges[i];
+    const name2 = change.item.data.name;
+    if (!name2) {
+      throw new Error(`Column in ...t.${change.type}() must have a name`);
+    }
+    const arr = shape[name2] ? orchidCore.toArray(shape[name2]) : [];
+    arr[up ? "push" : "unshift"](
+      up ? change : __spreadProps$5(__spreadValues$7({}, change), { type: change.type === "add" ? "drop" : "add" })
+    );
+    shape[name2] = arr;
+  }
   const [schema, table] = getSchemaAndTableFromName(name);
-  return __spreadValues$8({
+  return __spreadValues$7({
     type: "changeTable",
     schema,
     name: table,
@@ -793,7 +852,7 @@ const makeAst$1 = (up, name, changeData, changeTableData2, options) => {
   }, up ? changeTableData2 : { add: changeTableData2.drop, drop: changeTableData2.add });
 };
 const astToQueries = (ast, snakeCase, language) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  var _a;
   const queries = [];
   if (ast.comment !== void 0) {
     queries.push({
@@ -808,39 +867,26 @@ const astToQueries = (ast, snakeCase, language) => {
   };
   for (const key in ast.shape) {
     const item = ast.shape[key];
-    if ("item" in item) {
-      const { item: column } = item;
-      if (column instanceof pqb.EnumColumn) {
-        queries.push(makePopulateEnumQuery(column));
-      }
-    }
-    if (item.type === "add") {
-      if (item.item.data.isPrimaryKey) {
-        addPrimaryKeys.columns.push(getColumnName(item.item, key, snakeCase));
-      }
-    } else if (item.type === "drop") {
-      if (item.item.data.isPrimaryKey) {
-        dropPrimaryKeys.columns.push(getColumnName(item.item, key, snakeCase));
-      }
-    } else if (item.type === "change") {
-      if (item.from.column instanceof pqb.EnumColumn) {
-        queries.push(makePopulateEnumQuery(item.from.column));
-      }
-      if (item.to.column instanceof pqb.EnumColumn) {
-        queries.push(makePopulateEnumQuery(item.to.column));
-      }
-      if (item.from.primaryKey) {
-        dropPrimaryKeys.columns.push(
-          item.from.column ? getColumnName(item.from.column, key, snakeCase) : snakeCase ? orchidCore.toSnakeCase(key) : key
-        );
-        dropPrimaryKeys.change = true;
-      }
-      if (item.to.primaryKey) {
-        addPrimaryKeys.columns.push(
-          item.to.column ? getColumnName(item.to.column, key, snakeCase) : snakeCase ? orchidCore.toSnakeCase(key) : key
+    if (Array.isArray(item)) {
+      for (const it of item) {
+        handlePrerequisitesForTableItem(
+          key,
+          it,
+          queries,
+          addPrimaryKeys,
+          dropPrimaryKeys,
+          snakeCase
         );
-        addPrimaryKeys.change = true;
       }
+    } else {
+      handlePrerequisitesForTableItem(
+        key,
+        item,
+        queries,
+        addPrimaryKeys,
+        dropPrimaryKeys,
+        snakeCase
+      );
     }
   }
   if (ast.add.primaryKey) {
@@ -852,6 +898,7 @@ const astToQueries = (ast, snakeCase, language) => {
     dropPrimaryKeys.columns.push(...ast.drop.primaryKey.columns);
   }
   const alterTable = [];
+  const renameItems = [];
   const values = [];
   const addIndexes = mapIndexesForSnakeCase(ast.add.indexes, snakeCase);
   const dropIndexes = mapIndexesForSnakeCase(ast.drop.indexes, snakeCase);
@@ -866,149 +913,45 @@ const astToQueries = (ast, snakeCase, language) => {
   const comments = [];
   for (const key in ast.shape) {
     const item = ast.shape[key];
-    if (item.type === "add") {
-      const column = item.item;
-      const name = getColumnName(column, key, snakeCase);
-      addColumnIndex(addIndexes, name, column);
-      addColumnComment(comments, name, column);
-      alterTable.push(
-        `ADD COLUMN ${columnToSql(
-          name,
-          column,
+    if (Array.isArray(item)) {
+      for (const it of item) {
+        handleTableItemChange(
+          key,
+          it,
+          ast,
+          alterTable,
+          renameItems,
           values,
-          addPrimaryKeys.columns.length > 1,
+          addPrimaryKeys,
+          addIndexes,
+          dropIndexes,
+          addConstraints,
+          dropConstraints,
+          comments,
           snakeCase
-        )}`
-      );
-    } else if (item.type === "drop") {
-      const name = getColumnName(item.item, key, snakeCase);
-      alterTable.push(
-        `DROP COLUMN "${name}"${item.dropMode ? ` ${item.dropMode}` : ""}`
-      );
-    } else if (item.type === "change") {
-      const { from, to } = item;
-      const name = getChangeColumnName(item, key, snakeCase);
-      let changeType = false;
-      if (to.type && (from.type !== to.type || from.collate !== to.collate)) {
-        changeType = true;
-        const type = !to.column || to.column.data.isOfCustomType ? `"${to.type}"` : to.type;
-        alterTable.push(
-          `ALTER COLUMN "${name}" TYPE ${type}${to.collate ? ` COLLATE ${quoteNameFromString(to.collate)}` : ""}${item.using ? ` USING ${item.using.toSQL({ values })}` : ""}`
-        );
-      }
-      if (typeof from.identity !== typeof to.identity || !orchidCore.deepCompare(from.identity, to.identity)) {
-        alterTable.push(
-          `ALTER COLUMN "${name}" ${to.identity ? `ADD ${identityToSql(to.identity)}` : `DROP IDENTITY`}`
-        );
-      }
-      if (from.default !== to.default) {
-        const value = encodeColumnDefault(to.default, values, to.column);
-        if (changeType && value !== null) {
-          alterTable.push(`ALTER COLUMN "${name}" DROP DEFAULT`);
-        }
-        const expr = value === null ? "DROP DEFAULT" : `SET DEFAULT ${value}`;
-        alterTable.push(`ALTER COLUMN "${name}" ${expr}`);
-      }
-      if (from.nullable !== to.nullable) {
-        alterTable.push(
-          `ALTER COLUMN "${name}" ${to.nullable ? "DROP" : "SET"} NOT NULL`
-        );
-      }
-      if (from.compression !== to.compression) {
-        alterTable.push(
-          `ALTER COLUMN "${name}" SET COMPRESSION ${to.compression || "DEFAULT"}`
         );
       }
-      if (from.check !== to.check) {
-        const checkName = `${ast.name}_${name}_check`;
-        if (from.check) {
-          alterTable.push(`DROP CONSTRAINT "${checkName}"`);
-        }
-        if (to.check) {
-          alterTable.push(
-            `ADD CONSTRAINT "${checkName}"
-    CHECK (${to.check.toSQL({
-              values
-            })})`
-          );
-        }
-      }
-      const foreignKeysLen = Math.max(
-        ((_a = from.foreignKeys) == null ? void 0 : _a.length) || 0,
-        ((_b = to.foreignKeys) == null ? void 0 : _b.length) || 0
-      );
-      for (let i = 0; i < foreignKeysLen; i++) {
-        const fromFkey = (_c = from.foreignKeys) == null ? void 0 : _c[i];
-        const toFkey = (_d = to.foreignKeys) == null ? void 0 : _d[i];
-        if ((fromFkey || toFkey) && (!fromFkey || !toFkey || fromFkey.name !== toFkey.name || fromFkey.match !== toFkey.match || fromFkey.onUpdate !== toFkey.onUpdate || fromFkey.onDelete !== toFkey.onDelete || fromFkey.dropMode !== toFkey.dropMode || fromFkey.table !== toFkey.table || fromFkey.columns.join(",") !== toFkey.columns.join(","))) {
-          if (fromFkey) {
-            dropConstraints.push({
-              name: fromFkey.name,
-              dropMode: fromFkey.dropMode,
-              references: {
-                columns: [name],
-                fnOrTable: fromFkey.table,
-                foreignColumns: snakeCase ? fromFkey.columns.map(orchidCore.toSnakeCase) : fromFkey.columns,
-                options: fromFkey
-              }
-            });
-          }
-          if (toFkey) {
-            addConstraints.push({
-              name: toFkey.name,
-              dropMode: toFkey.dropMode,
-              references: {
-                columns: [name],
-                fnOrTable: toFkey.table,
-                foreignColumns: snakeCase ? toFkey.columns.map(orchidCore.toSnakeCase) : toFkey.columns,
-                options: toFkey
-              }
-            });
-          }
-        }
-      }
-      const indexesLen = Math.max(
-        ((_e = from.indexes) == null ? void 0 : _e.length) || 0,
-        ((_f = to.indexes) == null ? void 0 : _f.length) || 0
-      );
-      for (let i = 0; i < indexesLen; i++) {
-        const fromIndex = (_g = from.indexes) == null ? void 0 : _g[i];
-        const toIndex = (_h = to.indexes) == null ? void 0 : _h[i];
-        if ((fromIndex || toIndex) && (!fromIndex || !toIndex || fromIndex.collate !== toIndex.collate || fromIndex.opclass !== toIndex.opclass || fromIndex.order !== toIndex.order || fromIndex.name !== toIndex.name || fromIndex.unique !== toIndex.unique || fromIndex.using !== toIndex.using || fromIndex.include !== toIndex.include || Array.isArray(fromIndex.include) && Array.isArray(toIndex.include) && fromIndex.include.join(",") !== toIndex.include.join(",") || fromIndex.with !== toIndex.with || fromIndex.tablespace !== toIndex.tablespace || fromIndex.where !== toIndex.where || fromIndex.dropMode !== toIndex.dropMode)) {
-          if (fromIndex) {
-            dropIndexes.push({
-              columns: [
-                __spreadValues$8({
-                  column: name
-                }, fromIndex)
-              ],
-              options: fromIndex
-            });
-          }
-          if (toIndex) {
-            addIndexes.push({
-              columns: [
-                __spreadValues$8({
-                  column: name
-                }, toIndex)
-              ],
-              options: toIndex
-            });
-          }
-        }
-      }
-      if (from.comment !== to.comment) {
-        comments.push({ column: name, comment: to.comment || null });
-      }
-    } else if (item.type === "rename") {
-      alterTable.push(
-        `RENAME COLUMN "${snakeCase ? orchidCore.toSnakeCase(key) : key}" TO "${snakeCase ? orchidCore.toSnakeCase(item.name) : item.name}"`
+    } else {
+      handleTableItemChange(
+        key,
+        item,
+        ast,
+        alterTable,
+        renameItems,
+        values,
+        addPrimaryKeys,
+        addIndexes,
+        dropIndexes,
+        addConstraints,
+        dropConstraints,
+        comments,
+        snakeCase
       );
     }
   }
   const prependAlterTable = [];
   if (ast.drop.primaryKey || dropPrimaryKeys.change || dropPrimaryKeys.columns.length > 1) {
-    const name = ((_i = dropPrimaryKeys.options) == null ? void 0 : _i.name) || `${ast.name}_pkey`;
+    const name = ((_a = dropPrimaryKeys.options) == null ? void 0 : _a.name) || `${ast.name}_pkey`;
     prependAlterTable.push(`DROP CONSTRAINT "${name}"`);
   }
   prependAlterTable.push(
@@ -1034,42 +977,237 @@ const astToQueries = (ast, snakeCase, language) => {
  ADD ${constraintToSql(ast, true, foreignKey, values, snakeCase)}`
     )
   );
+  const tableName = quoteWithSchema(ast);
+  if (renameItems.length) {
+    queries.push(alterTableSql(tableName, renameItems, values));
+  }
   if (alterTable.length) {
-    queries.push({
-      text: `ALTER TABLE ${quoteWithSchema(ast)}
-  ${alterTable.join(",\n  ")}`,
-      values
-    });
+    queries.push(alterTableSql(tableName, alterTable, values));
   }
   queries.push(...indexesToQuery(false, ast, dropIndexes, language));
   queries.push(...indexesToQuery(true, ast, addIndexes, language));
   queries.push(...commentsToQuery(ast, comments));
   return queries;
 };
-const getChangeColumnName = (change, key, snakeCase) => {
-  return change.name || (change.to.column ? getColumnName(change.to.column, key, snakeCase) : snakeCase ? orchidCore.toSnakeCase(key) : key);
+const alterTableSql = (tableName, lines, values) => ({
+  text: `ALTER TABLE ${tableName}
+  ${lines.join(",\n  ")}`,
+  values
+});
+const handlePrerequisitesForTableItem = (key, item, queries, addPrimaryKeys, dropPrimaryKeys, snakeCase) => {
+  if ("item" in item) {
+    const { item: column } = item;
+    if (column instanceof pqb.EnumColumn) {
+      queries.push(makePopulateEnumQuery(column));
+    }
+  }
+  if (item.type === "add") {
+    if (item.item.data.primaryKey) {
+      addPrimaryKeys.columns.push(getColumnName(item.item, key, snakeCase));
+    }
+  } else if (item.type === "drop") {
+    if (item.item.data.primaryKey) {
+      dropPrimaryKeys.columns.push(getColumnName(item.item, key, snakeCase));
+    }
+  } else if (item.type === "change") {
+    if (item.from.column instanceof pqb.EnumColumn) {
+      queries.push(makePopulateEnumQuery(item.from.column));
+    }
+    if (item.to.column instanceof pqb.EnumColumn) {
+      queries.push(makePopulateEnumQuery(item.to.column));
+    }
+    if (item.from.primaryKey) {
+      dropPrimaryKeys.columns.push(
+        item.from.column ? getColumnName(item.from.column, key, snakeCase) : snakeCase ? orchidCore.toSnakeCase(key) : key
+      );
+      dropPrimaryKeys.change = true;
+    }
+    if (item.to.primaryKey) {
+      addPrimaryKeys.columns.push(
+        item.to.column ? getColumnName(item.to.column, key, snakeCase) : snakeCase ? orchidCore.toSnakeCase(key) : key
+      );
+      addPrimaryKeys.change = true;
+    }
+  }
+};
+const handleTableItemChange = (key, item, ast, alterTable, renameItems, values, addPrimaryKeys, addIndexes, dropIndexes, addConstraints, dropConstraints, comments, snakeCase) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  if (item.type === "add") {
+    const column = item.item;
+    const name = getColumnName(column, key, snakeCase);
+    addColumnIndex(addIndexes, name, column);
+    addColumnComment(comments, name, column);
+    alterTable.push(
+      `ADD COLUMN ${columnToSql(
+        name,
+        column,
+        values,
+        addPrimaryKeys.columns.length > 1,
+        snakeCase
+      )}`
+    );
+  } else if (item.type === "drop") {
+    const name = getColumnName(item.item, key, snakeCase);
+    alterTable.push(
+      `DROP COLUMN "${name}"${item.dropMode ? ` ${item.dropMode}` : ""}`
+    );
+  } else if (item.type === "change") {
+    const { from, to } = item;
+    const name = getChangeColumnName("to", item, key, snakeCase);
+    const fromName = getChangeColumnName("from", item, key, snakeCase);
+    if (fromName !== name) {
+      renameItems.push(renameColumnSql(fromName, name, snakeCase));
+    }
+    let changeType = false;
+    if (to.type && (from.type !== to.type || from.collate !== to.collate)) {
+      changeType = true;
+      const type = !to.column || to.column.data.isOfCustomType ? quoteNameFromString(to.type) : to.type;
+      alterTable.push(
+        `ALTER COLUMN "${name}" TYPE ${type}${to.collate ? ` COLLATE ${quoteNameFromString(to.collate)}` : ""}${((_a = item.using) == null ? void 0 : _a.usingUp) ? ` USING ${item.using.usingUp.toSQL({ values })}` : to.column instanceof pqb.EnumColumn ? ` USING "${name}"::text::${type}` : ""}`
+      );
+    }
+    if (typeof from.identity !== typeof to.identity || !orchidCore.deepCompare(from.identity, to.identity)) {
+      if (from.identity) {
+        alterTable.push(`ALTER COLUMN "${name}" DROP IDENTITY`);
+      }
+      if (to.identity) {
+        alterTable.push(
+          `ALTER COLUMN "${name}" ADD ${identityToSql(to.identity)}`
+        );
+      }
+    }
+    if (from.default !== to.default) {
+      const value = encodeColumnDefault(to.default, values, to.column);
+      if (changeType && value !== null) {
+        alterTable.push(`ALTER COLUMN "${name}" DROP DEFAULT`);
+      }
+      const expr = value === null ? "DROP DEFAULT" : `SET DEFAULT ${value}`;
+      alterTable.push(`ALTER COLUMN "${name}" ${expr}`);
+    }
+    if (from.nullable !== to.nullable) {
+      alterTable.push(
+        `ALTER COLUMN "${name}" ${to.nullable ? "DROP" : "SET"} NOT NULL`
+      );
+    }
+    if (from.compression !== to.compression) {
+      alterTable.push(
+        `ALTER COLUMN "${name}" SET COMPRESSION ${to.compression || "DEFAULT"}`
+      );
+    }
+    if (from.check !== to.check) {
+      const checkName = `${ast.name}_${name}_check`;
+      if (from.check) {
+        alterTable.push(`DROP CONSTRAINT "${checkName}"`);
+      }
+      if (to.check) {
+        alterTable.push(
+          `ADD CONSTRAINT "${checkName}"
+    CHECK (${to.check.sql.toSQL({
+            values
+          })})`
+        );
+      }
+    }
+    const foreignKeysLen = Math.max(
+      ((_b = from.foreignKeys) == null ? void 0 : _b.length) || 0,
+      ((_c = to.foreignKeys) == null ? void 0 : _c.length) || 0
+    );
+    for (let i = 0; i < foreignKeysLen; i++) {
+      const fromFkey = (_d = from.foreignKeys) == null ? void 0 : _d[i];
+      const toFkey = (_e = to.foreignKeys) == null ? void 0 : _e[i];
+      if ((fromFkey || toFkey) && (!fromFkey || !toFkey || fromFkey.name !== toFkey.name || fromFkey.match !== toFkey.match || fromFkey.onUpdate !== toFkey.onUpdate || fromFkey.onDelete !== toFkey.onDelete || fromFkey.dropMode !== toFkey.dropMode || fromFkey.table !== toFkey.table || fromFkey.columns.join(",") !== toFkey.columns.join(","))) {
+        if (fromFkey) {
+          dropConstraints.push({
+            name: fromFkey.name,
+            dropMode: fromFkey.dropMode,
+            references: {
+              columns: [name],
+              fnOrTable: fromFkey.table,
+              foreignColumns: snakeCase ? fromFkey.columns.map(orchidCore.toSnakeCase) : fromFkey.columns,
+              options: fromFkey
+            }
+          });
+        }
+        if (toFkey) {
+          addConstraints.push({
+            name: toFkey.name,
+            dropMode: toFkey.dropMode,
+            references: {
+              columns: [name],
+              fnOrTable: toFkey.table,
+              foreignColumns: snakeCase ? toFkey.columns.map(orchidCore.toSnakeCase) : toFkey.columns,
+              options: toFkey
+            }
+          });
+        }
+      }
+    }
+    const indexesLen = Math.max(
+      ((_f = from.indexes) == null ? void 0 : _f.length) || 0,
+      ((_g = to.indexes) == null ? void 0 : _g.length) || 0
+    );
+    for (let i = 0; i < indexesLen; i++) {
+      const fromIndex = (_h = from.indexes) == null ? void 0 : _h[i];
+      const toIndex = (_i = to.indexes) == null ? void 0 : _i[i];
+      if ((fromIndex || toIndex) && (!fromIndex || !toIndex || fromIndex.collate !== toIndex.collate || fromIndex.opclass !== toIndex.opclass || fromIndex.order !== toIndex.order || fromIndex.name !== toIndex.name || fromIndex.unique !== toIndex.unique || fromIndex.using !== toIndex.using || fromIndex.include !== toIndex.include || Array.isArray(fromIndex.include) && Array.isArray(toIndex.include) && fromIndex.include.join(",") !== toIndex.include.join(",") || fromIndex.with !== toIndex.with || fromIndex.tablespace !== toIndex.tablespace || fromIndex.where !== toIndex.where || fromIndex.dropMode !== toIndex.dropMode)) {
+        if (fromIndex) {
+          dropIndexes.push({
+            columns: [
+              __spreadValues$7({
+                column: name
+              }, fromIndex)
+            ],
+            options: fromIndex
+          });
+        }
+        if (toIndex) {
+          addIndexes.push({
+            columns: [
+              __spreadValues$7({
+                column: name
+              }, toIndex)
+            ],
+            options: toIndex
+          });
+        }
+      }
+    }
+    if (from.comment !== to.comment) {
+      comments.push({ column: name, comment: to.comment || null });
+    }
+  } else if (item.type === "rename") {
+    renameItems.push(renameColumnSql(key, item.name, snakeCase));
+  }
+};
+const getChangeColumnName = (what, change, key, snakeCase) => {
+  return change.name || (change[what].column ? (
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    getColumnName(change[what].column, key, snakeCase)
+  ) : snakeCase ? orchidCore.toSnakeCase(key) : key);
+};
+const renameColumnSql = (from, to, snakeCase) => {
+  return `RENAME COLUMN "${snakeCase ? orchidCore.toSnakeCase(from) : from}" TO "${snakeCase ? orchidCore.toSnakeCase(to) : to}"`;
 };
 const mapIndexesForSnakeCase = (indexes, snakeCase) => {
   return (indexes == null ? void 0 : indexes.map((index) => ({
     options: index.options,
     columns: snakeCase ? index.columns.map(
-      (item) => "column" in item ? __spreadProps$5(__spreadValues$8({}, item), { column: orchidCore.toSnakeCase(item.column) }) : item
+      (item) => "column" in item ? __spreadProps$5(__spreadValues$7({}, item), { column: orchidCore.toSnakeCase(item.column) }) : item
     ) : index.columns
   }))) || [];
 };
 const mapConstraintsToSnakeCase = (foreignKeys, snakeCase) => {
-  return (foreignKeys == null ? void 0 : foreignKeys.map((item) => __spreadProps$5(__spreadValues$8({}, item), {
-    references: item.references ? snakeCase ? __spreadProps$5(__spreadValues$8({}, item.references), {
+  return (foreignKeys == null ? void 0 : foreignKeys.map((item) => __spreadProps$5(__spreadValues$7({}, item), {
+    references: item.references ? snakeCase ? __spreadProps$5(__spreadValues$7({}, item.references), {
       columns: item.references.columns.map(orchidCore.toSnakeCase)
     }) : item.references : void 0
   }))) || [];
 };
 
-const createView$1 = async (migration, up, name, options, sql) => {
+const createView = async (migration, up, name, options, sql) => {
   const ast = makeAst(up, name, options, sql);
   const query = astToQuery(ast);
   await migration.adapter.query(query);
-  migration.migratedAsts.push(ast);
 };
 const makeAst = (up, name, options, sql) => {
   if (typeof sql === "string") {
@@ -1081,7 +1219,8 @@ const makeAst = (up, name, options, sql) => {
     name,
     shape: {},
     sql,
-    options
+    options,
+    deps: []
   };
 };
 const astToQuery = (ast) => {
@@ -1127,26 +1266,26 @@ const astToQuery = (ast) => {
   };
 };
 
-var __defProp$7 = Object.defineProperty;
+var __defProp$6 = Object.defineProperty;
 var __defProps$4 = Object.defineProperties;
 var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
-var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
-var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$7 = (a, b) => {
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$6 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$7.call(b, prop))
-      __defNormalProp$7(a, prop, b[prop]);
-  if (__getOwnPropSymbols$7)
-    for (var prop of __getOwnPropSymbols$7(b)) {
-      if (__propIsEnum$7.call(b, prop))
-        __defNormalProp$7(a, prop, b[prop]);
+    if (__hasOwnProp$6.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b)) {
+      if (__propIsEnum$6.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
     }
   return a;
 };
 var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
-const createMigrationInterface = (tx, up, config, asts) => {
+const createMigrationInterface = (tx, up, config) => {
   var _a;
   const adapter = new pqb.TransactionAdapter(
     tx,
@@ -1171,7 +1310,6 @@ const createMigrationInterface = (tx, up, config, asts) => {
   for (const key of Object.getOwnPropertyNames(proto)) {
     db[key] = proto[key];
   }
-  db.migratedAsts = asts;
   return Object.assign(db, {
     adapter,
     log,
@@ -1183,12 +1321,12 @@ class Migration {
   createTable(tableName, cbOrOptions, cb) {
     const options = !cbOrOptions || typeof cbOrOptions === "function" ? {} : cbOrOptions;
     const fn = typeof cbOrOptions === "function" ? cbOrOptions : cb;
-    return createTable$1(this, this.up, tableName, options, fn);
+    return createTable(this, this.up, tableName, options, fn);
   }
   dropTable(tableName, cbOrOptions, cb) {
     const options = !cbOrOptions || typeof cbOrOptions === "function" ? {} : cbOrOptions;
     const fn = typeof cbOrOptions === "function" ? cbOrOptions : cb;
-    return createTable$1(this, !this.up, tableName, options, fn);
+    return createTable(this, !this.up, tableName, options, fn);
   }
   changeTable(tableName, cbOrOptions, cb) {
     const [fn, options] = typeof cbOrOptions === "function" ? [cbOrOptions, {}] : [cb, cbOrOptions];
@@ -1219,7 +1357,7 @@ class Migration {
    * @param to - rename the table to
    */
   renameTable(from, to) {
-    return renameType(this, from, to, true);
+    return renameType(this, from, to, "TABLE");
   }
   /**
    * Set a different schema to the table:
@@ -1309,6 +1447,25 @@ class Migration {
   dropIndex(tableName, columns, options) {
     return addIndex(this, !this.up, tableName, columns, options);
   }
+  /**
+   * Rename index:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   // tableName can be prefixed with a schema
+   *   await db.renameIndex('tableName', 'oldIndexName', 'newIndexName');
+   * });
+   * ```
+   *
+   * @param tableName - table which this index belongs to
+   * @param from - rename the index from
+   * @param to - rename the index to
+   */
+  renameIndex(tableName, from, to) {
+    return renameTableItem(this, tableName, from, to, "INDEX");
+  }
   /**
    * Add a foreign key to a table on migrating, and remove it on rollback.
    *
@@ -1476,6 +1633,28 @@ class Migration {
   dropConstraint(tableName, constraint) {
     return addConstraint(this, !this.up, tableName, constraint);
   }
+  /**
+   * Rename a table constraint, such as primary key, or check.
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.renameConstraint(
+   *     'tableName', // may include schema: 'schema.table'
+   *     'oldConstraintName',
+   *     'newConstraintName',
+   *   );
+   * });
+   * ```
+   *
+   * @param tableName - name of the table containing the constraint, may include schema name, may include schema name
+   * @param from - current name of the constraint
+   * @param to - desired name
+   */
+  renameConstraint(tableName, from, to) {
+    return renameTableItem(this, tableName, from, to, "CONSTRAINT");
+  }
   /**
    * Rename a column:
    *
@@ -1512,17 +1691,36 @@ class Migration {
    * @param schemaName - name of the schema
    */
   createSchema(schemaName) {
-    return createSchema$1(this, this.up, schemaName);
+    return createSchema(this, this.up, schemaName);
   }
   /**
-   * Drop the schema, create it on rollback. See {@link createSchema}.
+   * Renames a database schema, renames it backwards on roll back.
    *
-   * @param schemaName - name of the schema
-   */
-  dropSchema(schemaName) {
-    return createSchema$1(this, !this.up, schemaName);
-  }
-  /**
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.renameSchema('from', 'to');
+   * });
+   * ```
+   *
+   * @param from - existing schema to rename
+   * @param to - desired schema name
+   */
+  async renameSchema(from, to) {
+    await this.adapter.query(
+      `ALTER SCHEMA "${this.up ? from : to}" RENAME TO "${this.up ? to : from}"`
+    );
+  }
+  /**
+   * Drop the schema, create it on rollback. See {@link createSchema}.
+   *
+   * @param schemaName - name of the schema
+   */
+  dropSchema(schemaName) {
+    return createSchema(this, !this.up, schemaName);
+  }
+  /**
    * `createExtension` creates a database extension, and removes it on rollback.
    *
    * `dropExtension` takes the same arguments, removes the extension on migrate, and adds it on rollback.
@@ -1538,8 +1736,8 @@ class Migration {
    * @param name - name of the extension
    * @param options - extension options
    */
-  createExtension(name, options = {}) {
-    return createExtension$1(this, this.up, name, options);
+  createExtension(name, options) {
+    return createExtension(this, this.up, name, options);
   }
   /**
    * Drop the extension, create it on rollback. See {@link createExtension}.
@@ -1547,8 +1745,8 @@ class Migration {
    * @param name - name of the extension
    * @param options - extension options
    */
-  dropExtension(name, options = {}) {
-    return createExtension$1(this, !this.up, name, options);
+  dropExtension(name, options) {
+    return createExtension(this, !this.up, name, options);
   }
   /**
    * `createEnum` creates an enum on migrate, drops it on rollback.
@@ -1577,7 +1775,7 @@ class Migration {
    * @param options - enum options
    */
   createEnum(name, values, options) {
-    return createEnum$1(this, this.up, name, values, options);
+    return createEnum(this, this.up, name, values, options);
   }
   /**
    * Drop the enum, create it on rollback. See {@link createEnum}.
@@ -1587,7 +1785,7 @@ class Migration {
    * @param options - enum options
    */
   dropEnum(name, values, options) {
-    return createEnum$1(this, !this.up, name, values, options);
+    return createEnum(this, !this.up, name, values, options);
   }
   /**
    * Use these methods to add or drop one or multiple values from an existing enum.
@@ -1731,7 +1929,7 @@ class Migration {
    * @param to - rename the type to
    */
   renameType(from, to) {
-    return renameType(this, from, to, false);
+    return renameType(this, from, to, "TYPE");
   }
   /**
    * Set a different schema to the type (such as enum):
@@ -1752,48 +1950,67 @@ class Migration {
     return this.renameType(`${from}.${name}`, `${to}.${name}`);
   }
   /**
-   * Domain is a custom database type that allows to predefine a `NOT NULL` and a `CHECK` (see [postgres tutorial](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-user-defined-data-types/)).
+   * Domain is a custom database type that is based on other type and can include `NOT NULL` and a `CHECK` (see [postgres tutorial](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-user-defined-data-types/)).
    *
-   * `createDomain` and `dropDomain` take a domain name as first argument, callback returning inner column type as a second, and optional object with parameters as third.
+   * Construct a column type in the function as the second argument.
+   *
+   * Specifiers [nullable](/guide/common-column-methods.html#nullable), [default](/guide/common-column-methods.html#default), [check](/guide/migration-column-methods.html#check), [collate](/guide/migration-column-methods.html#collate)
+   * will be saved to the domain type on database level.
    *
    * ```ts
    * import { change } from '../dbScript';
    *
    * change(async (db) => {
-   *   await db.createDomain('domainName', (t) => t.integer(), {
-   *     check: db.sql`value = 42`,
-   *   });
+   *   await db.createDomain('domainName', (t) =>
+   *     t.integer().check(db.sql`value = 42`),
+   *   );
    *
    *   // use `schemaName.domainName` format to specify a schema
-   *   await db.createDomain('schemaName.domainName', (t) => t.text(), {
-   *     // unlike columns, domain is nullable by default, use notNull when needed:
-   *     notNull: true,
-   *     collation: 'C',
-   *     default: db.sql`'default text'`,
-   *     check: db.sql`length(value) > 10`,
-   *
-   *     // cascade is used when dropping domain
-   *     cascade: true,
-   *   });
+   *   await db.createDomain('schemaName.domainName', (t) =>
+   *     t
+   *       .text()
+   *       .nullable()
+   *       .collate('C')
+   *       .default('default text')
+   *       .check(db.sql`length(value) > 10`),
+   *   );
    * });
    * ```
    *
    * @param name - name of the domain
-   * @param fn - function returning a column type for the domain
-   * @param options - domain options
+   * @param fn - function returning a column type. Options `nullable`, `collate`, `default`, `check` will be applied to domain
    */
-  createDomain(name, fn, options) {
-    return createDomain$1(this, this.up, name, fn, options);
+  createDomain(name, fn) {
+    return createDomain(this, this.up, name, fn);
   }
   /**
    * Drop the domain, create it on rollback. See {@link dropDomain}.
    *
    * @param name - name of the domain
-   * @param fn - function returning a column type for the domain
-   * @param options - domain options
+   * @param fn - function returning a column type. Options `nullable`, `collate`, `default`, `check` will be applied to domain
+   */
+  dropDomain(name, fn) {
+    return createDomain(this, !this.up, name, fn);
+  }
+  /**
+   * To rename a domain:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.renameDomain('oldName', 'newName');
+   *
+   *   // to move domain to a different schema
+   *   await db.renameDomain('oldSchema.domain', 'newSchema.domain');
+   * });
+   * ```
+   *
+   * @param from - old domain name (can include schema)
+   * @param to - new domain name (can include schema)
    */
-  dropDomain(name, fn, options) {
-    return createDomain$1(this, !this.up, name, fn, options);
+  renameDomain(from, to) {
+    return renameType(this, from, to, "DOMAIN");
   }
   /**
    * Create and drop a database collation, (see [Postgres docs](https://www.postgresql.org/docs/current/sql-createcollation.html)).
@@ -1860,7 +2077,7 @@ class Migration {
    * @param options - options to create and drop the collation.
    */
   createCollation(name, options) {
-    return createCollation$1(this, this.up, name, options);
+    return createCollation(this, this.up, name, options);
   }
   /**
    * Drop the collation, create it on rollback. See {@link createCollation}.
@@ -1869,11 +2086,11 @@ class Migration {
    * @param options - options to create and drop the collation.
    */
   dropCollation(name, options) {
-    return createCollation$1(this, !this.up, name, options);
+    return createCollation(this, !this.up, name, options);
   }
   createView(name, ...args) {
     const [options, sql] = args.length === 2 ? args : [orchidCore.emptyObject, args[0]];
-    return createView$1(
+    return createView(
       this,
       this.up,
       name,
@@ -1883,7 +2100,7 @@ class Migration {
   }
   dropView(name, ...args) {
     const [options, sql] = args.length === 2 ? args : [orchidCore.emptyObject, args[0]];
-    return createView$1(
+    return createView(
       this,
       !this.up,
       name,
@@ -1962,7 +2179,7 @@ const wrapWithLog = async (log, query, fn) => {
   if (!log) {
     return fn();
   } else {
-    const sql = typeof query === "string" ? { text: query, values: [] } : query.values ? query : __spreadProps$4(__spreadValues$7({}, query), { values: [] });
+    const sql = typeof query === "string" ? { text: query, values: [] } : query.values ? query : __spreadProps$4(__spreadValues$6({}, query), { values: [] });
     const logData = log.beforeQuery(sql);
     try {
       const result = await fn();
@@ -1980,21 +2197,21 @@ const addColumn = (migration, up, tableName, columnName, fn) => {
   }));
 };
 const addIndex = (migration, up, tableName, columns, options) => {
-  return changeTable(migration, up, tableName, {}, (t) => __spreadValues$7({}, t.add(t.index(columns, options))));
+  return changeTable(migration, up, tableName, {}, (t) => __spreadValues$6({}, t.add(t.index(columns, options))));
 };
 const addForeignKey = (migration, up, tableName, columns, foreignTable, foreignColumns, options) => {
-  return changeTable(migration, up, tableName, {}, (t) => __spreadValues$7({}, t.add(t.foreignKey(columns, foreignTable, foreignColumns, options))));
+  return changeTable(migration, up, tableName, {}, (t) => __spreadValues$6({}, t.add(t.foreignKey(columns, foreignTable, foreignColumns, options))));
 };
 const addPrimaryKey = (migration, up, tableName, columns, options) => {
-  return changeTable(migration, up, tableName, {}, (t) => __spreadValues$7({}, t.add(t.primaryKey(columns, options))));
+  return changeTable(migration, up, tableName, {}, (t) => __spreadValues$6({}, t.add(t.primaryKey(columns, options))));
 };
 const addCheck = (migration, up, tableName, check) => {
-  return changeTable(migration, up, tableName, {}, (t) => __spreadValues$7({}, t.add(t.check(check))));
+  return changeTable(migration, up, tableName, {}, (t) => __spreadValues$6({}, t.add(t.check(check))));
 };
 const addConstraint = (migration, up, tableName, constraint) => {
-  return changeTable(migration, up, tableName, {}, (t) => __spreadValues$7({}, t.add(t.constraint(constraint))));
+  return changeTable(migration, up, tableName, {}, (t) => __spreadValues$6({}, t.add(t.constraint(constraint))));
 };
-const createSchema$1 = async (migration, up, name) => {
+const createSchema = async (migration, up, name) => {
   const ast = {
     type: "schema",
     action: up ? "create" : "drop",
@@ -2003,12 +2220,13 @@ const createSchema$1 = async (migration, up, name) => {
   await migration.adapter.query(
     `${ast.action === "create" ? "CREATE" : "DROP"} SCHEMA "${name}"`
   );
-  migration.migratedAsts.push(ast);
 };
-const createExtension$1 = async (migration, up, name, options) => {
-  const ast = __spreadValues$7({
+const createExtension = async (migration, up, fullName, options) => {
+  const [schema, name] = getSchemaAndTableFromName(fullName);
+  const ast = __spreadValues$6({
     type: "extension",
     action: up ? "create" : "drop",
+    schema,
     name
   }, options);
   let query;
@@ -2018,11 +2236,10 @@ const createExtension$1 = async (migration, up, name, options) => {
     query = `CREATE EXTENSION${ast.createIfNotExists ? " IF NOT EXISTS" : ""} "${ast.name}"${ast.schema ? ` SCHEMA "${ast.schema}"` : ""}${ast.version ? ` VERSION '${ast.version}'` : ""}${ast.cascade ? " CASCADE" : ""}`;
   }
   await migration.adapter.query(query);
-  migration.migratedAsts.push(ast);
 };
-const createEnum$1 = async (migration, up, name, values, options = {}) => {
+const createEnum = async (migration, up, name, values, options = {}) => {
   const [schema, enumName] = getSchemaAndTableFromName(name);
-  const ast = __spreadValues$7({
+  const ast = __spreadValues$6({
     type: "enum",
     action: up ? "create" : "drop",
     schema,
@@ -2037,39 +2254,38 @@ const createEnum$1 = async (migration, up, name, values, options = {}) => {
     query = `DROP TYPE${ast.dropIfExists ? " IF EXISTS" : ""} ${quotedName}${ast.cascade ? " CASCADE" : ""}`;
   }
   await migration.adapter.query(query);
-  migration.migratedAsts.push(ast);
 };
-const createDomain$1 = async (migration, up, name, fn, options) => {
+const createDomain = async (migration, up, name, fn) => {
   const [schema, domainName] = getSchemaAndTableFromName(name);
-  const ast = __spreadValues$7({
+  const ast = {
     type: "domain",
     action: up ? "create" : "drop",
     schema,
     name: domainName,
     baseType: fn(migration.columnTypes)
-  }, options);
+  };
   let query;
   const values = [];
   const quotedName = quoteWithSchema(ast);
   if (ast.action === "create") {
-    query = `CREATE DOMAIN ${quotedName} AS ${columnTypeToSql(ast.baseType)}${ast.collation ? `
-COLLATION ${orchidCore.singleQuote(ast.collation)}` : ""}${ast.default ? `
-DEFAULT ${ast.default.toSQL({ values })}` : ""}${ast.notNull || ast.check ? "\n" : ""}${[
-      ast.notNull && "NOT NULL",
-      ast.check && `CHECK ${ast.check.toSQL({ values })}`
+    const column = ast.baseType;
+    query = `CREATE DOMAIN ${quotedName} AS ${columnTypeToSql(column)}${column.data.collate ? `
+COLLATE "${column.data.collate}"` : ""}${column.data.default !== void 0 ? `
+DEFAULT ${encodeColumnDefault(column.data.default, values)}` : ""}${!column.data.isNullable || column.data.check ? "\n" : ""}${[
+      !column.data.isNullable && "NOT NULL",
+      column.data.check && `CHECK (${column.data.check.sql.toSQL({ values })})`
     ].filter(Boolean).join(" ")}`;
   } else {
-    query = `DROP DOMAIN ${quotedName}${ast.cascade ? " CASCADE" : ""}`;
+    query = `DROP DOMAIN ${quotedName}`;
   }
   await migration.adapter.query({
     text: query,
     values
   });
-  migration.migratedAsts.push(ast);
 };
-const createCollation$1 = async (migration, up, name, options) => {
+const createCollation = async (migration, up, name, options) => {
   const [schema, collationName] = getSchemaAndTableFromName(name);
-  const ast = __spreadValues$7({
+  const ast = __spreadValues$6({
     type: "collation",
     action: up ? "create" : "drop",
     schema,
@@ -2105,35 +2321,42 @@ const createCollation$1 = async (migration, up, name, options) => {
   await migration.adapter.query({
     text: query
   });
-  migration.migratedAsts.push(ast);
 };
 const queryExists = (db, sql) => {
   return db.adapter.query(sql).then(({ rowCount }) => rowCount > 0);
 };
-const renameType = async (migration, from, to, table) => {
+const renameType = async (migration, from, to, kind) => {
   var _a;
   const [fromSchema, f] = getSchemaAndTableFromName(migration.up ? from : to);
   const [toSchema, t] = getSchemaAndTableFromName(migration.up ? to : from);
   const ast = {
     type: "renameType",
-    table,
+    kind,
     fromSchema,
     from: f,
     toSchema,
     to: t
   };
-  const sqlKind = ast.table ? "TABLE" : "TYPE";
   if (ast.from !== ast.to) {
     await migration.adapter.query(
-      `ALTER ${sqlKind} ${quoteTable(ast.fromSchema, ast.from)} RENAME TO "${ast.to}"`
+      `ALTER ${ast.kind} ${quoteTable(ast.fromSchema, ast.from)} RENAME TO "${ast.to}"`
     );
   }
   if (ast.fromSchema !== ast.toSchema) {
     await migration.adapter.query(
-      `ALTER ${sqlKind} ${quoteTable(ast.fromSchema, ast.to)} SET SCHEMA "${(_a = ast.toSchema) != null ? _a : migration.adapter.schema}"`
+      `ALTER ${ast.kind} ${quoteTable(ast.fromSchema, ast.to)} SET SCHEMA "${(_a = ast.toSchema) != null ? _a : migration.adapter.schema}"`
     );
   }
-  migration.migratedAsts.push(ast);
+};
+const renameTableItem = async (migration, tableName, from, to, kind) => {
+  const [schema, table] = getSchemaAndTableFromName(tableName);
+  const [f, t] = migration.up ? [from, to] : [to, from];
+  await migration.adapter.query(
+    kind === "INDEX" ? `ALTER INDEX ${quoteTable(schema, f)} RENAME TO "${t}"` : `ALTER TABLE ${quoteTable(
+      schema,
+      table
+    )} RENAME CONSTRAINT "${f}" TO "${t}"`
+  );
 };
 const addOrDropEnumValues = async (migration, up, enumName, values, options) => {
   var _a;
@@ -2238,7 +2461,7 @@ GROUP BY n.nspname, c.relname`
   }
 };
 
-const writeMigrationFile = async (config, version, name, content) => {
+const writeMigrationFile = async (config, version, name, migrationCode) => {
   var _a;
   await fs.mkdir(config.migrationsPath, { recursive: true });
   const filePath = path.resolve(config.migrationsPath, `${version}_${name}.ts`);
@@ -2246,14 +2469,18 @@ const writeMigrationFile = async (config, version, name, content) => {
     filePath,
     path.join(config.basePath, config.dbScript)
   );
-  await fs.writeFile(filePath, content(importPath, name));
+  await fs.writeFile(
+    filePath,
+    `import { change } from '${importPath}';
+${migrationCode}`
+  );
   (_a = config.logger) == null ? void 0 : _a.log(`Created ${orchidCore.pathToLog(filePath)}`);
 };
-const generate = async (config, [name]) => {
+const newMigration = async (config, [name]) => {
   if (!name)
     throw new Error("Migration name is missing");
   const version = await makeFileVersion({}, config);
-  await writeMigrationFile(config, version, name, makeContent);
+  await writeMigrationFile(config, version, name, makeContent(name));
 };
 const makeFileVersion = async (ctx, config) => {
   if (config.migrationId === "timestamp") {
@@ -2276,9 +2503,8 @@ const generateTimeStamp = () => {
     now.getUTCSeconds()
   ].map((value) => value < 10 ? `0${value}` : value).join("");
 };
-const makeContent = (importPath, name) => {
-  let content = `import { change } from '${importPath}';
-
+const makeContent = (name) => {
+  let content = `
 change(async (db) => {`;
   const [first, rest] = getFirstWordAndRest(name);
   if (rest) {
@@ -2386,28 +2612,28 @@ const renameMigrationVersionsInDb = async (config, adapter, values) => {
   });
 };
 
-var __defProp$6 = Object.defineProperty;
+var __defProp$5 = Object.defineProperty;
 var __defProps$3 = Object.defineProperties;
 var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
-var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
-var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$6 = (a, b) => {
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$6.call(b, prop))
-      __defNormalProp$6(a, prop, b[prop]);
-  if (__getOwnPropSymbols$6)
-    for (var prop of __getOwnPropSymbols$6(b)) {
-      if (__propIsEnum$6.call(b, prop))
-        __defNormalProp$6(a, prop, b[prop]);
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
     }
   return a;
 };
 var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
 const getMigrations = async (ctx, config, up, allowDuplicates) => {
   var _a;
-  return ((_a = ctx.migrationsPromise) != null ? _a : ctx.migrationsPromise = config.migrations ? getMigrationsFromConfig(__spreadProps$3(__spreadValues$6({}, config), { migrations: config.migrations })) : getMigrationsFromFiles(config, allowDuplicates)).then(
+  return ((_a = ctx.migrationsPromise) != null ? _a : ctx.migrationsPromise = config.migrations ? getMigrationsFromConfig(__spreadProps$3(__spreadValues$5({}, config), { migrations: config.migrations })) : getMigrationsFromFiles(config, allowDuplicates)).then(
     (data) => up ? data : { renameTo: data.renameTo, migrations: [...data.migrations].reverse() }
   );
 };
@@ -2663,25 +2889,9 @@ const createMigrationsTable = async (db, config) => {
   }
 };
 
-var __defProp$5 = Object.defineProperty;
-var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
-var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
-var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$5 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$5.call(b, prop))
-      __defNormalProp$5(a, prop, b[prop]);
-  if (__getOwnPropSymbols$5)
-    for (var prop of __getOwnPropSymbols$5(b)) {
-      if (__propIsEnum$5.call(b, prop))
-        __defNormalProp$5(a, prop, b[prop]);
-    }
-  return a;
-};
 const RAKE_DB_LOCK_KEY = "8582141715823621641";
 function makeMigrateFn(defaultCount, up, fn) {
-  return async (ctx, options, config, args = []) => {
+  return async (ctx, options, config, args = [], adapters = options.map((opts) => new pqb.Adapter(opts)), dontClose) => {
     var _a;
     const set = await getMigrations(ctx, config, up);
     const arg = args[0];
@@ -2694,13 +2904,11 @@ function makeMigrateFn(defaultCount, up, fn) {
       const num = arg === "all" ? Infinity : parseInt(arg);
       count = isNaN(num) ? void 0 : num;
     }
-    const conf = prepareConfig(config, args, count === void 0 || force);
-    const asts = [];
-    const appCodeUpdaterCache = {};
-    const { appCodeUpdater } = conf;
-    let localAsts = asts;
-    for (const opts of options) {
-      const adapter = new pqb.Adapter(opts);
+    const conf = config;
+    const length = options.length;
+    for (let i = 0; i < length; i++) {
+      const opts = options[i];
+      const adapter = adapters[i];
       try {
         await transaction(adapter, async (trx) => {
           const versions = await getMigratedVersionsMap(
@@ -2715,7 +2923,6 @@ function makeMigrateFn(defaultCount, up, fn) {
             set,
             versions,
             count != null ? count : defaultCount,
-            localAsts,
             force
           );
         });
@@ -2730,83 +2937,40 @@ function makeMigrateFn(defaultCount, up, fn) {
               config2,
               set.renameTo
             );
-            await fn(
-              trx,
-              config2,
-              set,
-              versions,
-              count != null ? count : defaultCount,
-              localAsts,
-              force
-            );
+            await fn(trx, config2, set, versions, count != null ? count : defaultCount, force);
           });
         } else {
           throw err;
         }
       } finally {
-        await adapter.close();
+        if (!dontClose)
+          await adapter.close();
       }
-      localAsts = [];
       (_a = config.afterChangeCommit) == null ? void 0 : _a.call(config, {
         options: opts,
         up,
         migrations: set.migrations
       });
     }
-    await runCodeUpdaterAfterAll(
-      options[0],
-      config,
-      appCodeUpdater,
-      asts,
-      appCodeUpdaterCache
-    );
+    return adapters;
   };
 }
 const migrate = makeMigrateFn(
   Infinity,
   true,
-  (trx, config, set, versions, count, asts, force) => migrateOrRollback(
-    trx,
-    config,
-    set,
-    versions,
-    count,
-    asts,
-    true,
-    false,
-    force
-  )
+  (trx, config, set, versions, count, force) => migrateOrRollback(trx, config, set, versions, count, true, false, force)
 );
 const rollback = makeMigrateFn(
   1,
   false,
-  (trx, config, set, versions, count, asts, force) => migrateOrRollback(
-    trx,
-    config,
-    set,
-    versions,
-    count,
-    asts,
-    false,
-    false,
-    force
-  )
+  (trx, config, set, versions, count, force) => migrateOrRollback(trx, config, set, versions, count, false, false, force)
 );
 const redo = makeMigrateFn(
   1,
   true,
-  async (trx, config, set, versions, count, asts, force) => {
+  async (trx, config, set, versions, count, force) => {
     set.migrations.reverse();
-    await migrateOrRollback(
-      trx,
-      config,
-      set,
-      versions,
-      count,
-      asts,
-      false,
-      true
-    );
+    await migrateOrRollback(trx, config, set, versions, count, false, true);
     set.migrations.reverse();
     await migrateOrRollback(
       trx,
@@ -2814,7 +2978,6 @@ const redo = makeMigrateFn(
       set,
       versions,
       count,
-      asts,
       true,
       true,
       force,
@@ -2823,19 +2986,8 @@ const redo = makeMigrateFn(
   }
 );
 const getDb = (adapter) => pqb.createDb({ adapter });
-function prepareConfig(config, args, hasArg) {
-  config = __spreadValues$5({}, config);
-  const i = hasArg ? 0 : 1;
-  const arg = args[i];
-  if (arg === "--code") {
-    config.useCodeUpdater = args[i + 1] !== "false";
-  }
-  if (!config.useCodeUpdater)
-    delete config.appCodeUpdater;
-  return config;
-}
-const migrateOrRollback = async (trx, config, set, versions, count, asts, up, redo2, force, skipLock) => {
-  var _a, _b, _c;
+const migrateOrRollback = async (trx, config, set, versions, count, up, redo2, force, skipLock) => {
+  var _a, _b, _c, _d;
   const { sequence, map: versionsMap } = versions;
   if (up) {
     const rollbackTo = checkMigrationOrder(config, set, versions, force);
@@ -2856,7 +3008,6 @@ const migrateOrRollback = async (trx, config, set, versions, count, asts, up, re
         set,
         versions,
         sequence.length - i,
-        asts,
         false,
         redo2
       );
@@ -2873,13 +3024,21 @@ const migrateOrRollback = async (trx, config, set, versions, count, asts, up, re
     await (beforeMigrate == null ? void 0 : beforeMigrate({ db, migrations }));
     await ((_a = config.beforeChange) == null ? void 0 : _a.call(config, { db, migrations, up, redo: redo2 }));
   }
+  let loggedAboutStarting = false;
   for (const file of set.migrations) {
     if (up && versionsMap[file.version] || !up && !versionsMap[file.version]) {
       continue;
     }
     if (count-- <= 0)
       break;
-    await runMigration(trx, up, file, config, asts);
+    if (!loggedAboutStarting && (!redo2 || !up)) {
+      loggedAboutStarting = true;
+      (_b = config.logger) == null ? void 0 : _b.log(
+        `${redo2 ? "Reapplying migrations for" : up ? "Migrating" : "Rolling back"} database ${trx.config.connectionString ? new URL(trx.config.connectionString).pathname.slice(1) : trx.config.database}
+`
+      );
+    }
+    await runMigration(trx, up, file, config);
     if (up) {
       const name = path.basename(file.path);
       versionsMap[file.version] = name;
@@ -2888,15 +3047,16 @@ const migrateOrRollback = async (trx, config, set, versions, count, asts, up, re
       versionsMap[file.version] = void 0;
       sequence.pop();
     }
-    (_b = config.logger) == null ? void 0 : _b.log(
-      `${up ? "Migrated" : "Rolled back"} ${orchidCore.pathToLog(file.path)}`
+    (_c = config.logger) == null ? void 0 : _c.log(
+      `${up ? "Migrated" : "Rolled back"} ${orchidCore.pathToLog(file.path)}
+`
     );
   }
   const afterMigrate = config[up ? "afterMigrate" : "afterRollback"];
   if (config.afterChange || afterMigrate) {
     db != null ? db : db = getDb(trx);
     const { migrations } = set;
-    await ((_c = config.afterChange) == null ? void 0 : _c.call(config, { db, up, redo: redo2, migrations }));
+    await ((_d = config.afterChange) == null ? void 0 : _d.call(config, { db, up, redo: redo2, migrations }));
     await (afterMigrate == null ? void 0 : afterMigrate({ db, migrations }));
   }
 };
@@ -2920,31 +3080,8 @@ Run \`**db command** up force\` to rollback the above migrations and migrate all
   }
   return;
 };
-async function runCodeUpdaterAfterAll(options, config, appCodeUpdater, asts, cache) {
-  for (const ast of asts) {
-    await (appCodeUpdater == null ? void 0 : appCodeUpdater.process({
-      ast,
-      options,
-      basePath: config.basePath,
-      cache,
-      logger: config.logger,
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      baseTable: config.baseTable,
-      import: config.import
-    }));
-  }
-  await (appCodeUpdater == null ? void 0 : appCodeUpdater.afterAll({
-    options,
-    basePath: config.basePath,
-    cache,
-    logger: config.logger,
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    baseTable: config.baseTable,
-    import: config.import
-  }));
-}
 const changeCache = {};
-const runMigration = async (trx, up, file, config, asts) => {
+const runMigration = async (trx, up, file, config) => {
   clearChanges();
   let changes = changeCache[file.path];
   if (!changes) {
@@ -2958,7 +3095,7 @@ const runMigration = async (trx, up, file, config, asts) => {
     changes = exported || getCurrentChanges();
     changeCache[file.path] = changes;
   }
-  const db = createMigrationInterface(trx, up, config, asts);
+  const db = createMigrationInterface(trx, up, config);
   if (changes.length) {
     const from = up ? 0 : changes.length - 1;
     const to = up ? changes.length : -1;
@@ -3008,8 +3145,7 @@ const migrationConfigDefaults = {
     });
   },
   log: true,
-  logger: console,
-  useCodeUpdater: true
+  logger: console
 };
 const processRakeDbConfig = (config) => {
   var _a, _b;
@@ -3017,11 +3153,6 @@ const processRakeDbConfig = (config) => {
   if (!result.recurrentPath) {
     result.recurrentPath = path.join(result.migrationsPath, "recurrent");
   }
-  if (config.appCodeUpdater && (!("baseTable" in config) || !config.baseTable)) {
-    throw new Error(
-      "`baseTable` option is required in `rakeDb` for `appCodeUpdater`"
-    );
-  }
   if (!result.log) {
     delete result.logger;
   }
@@ -3083,6 +3214,204 @@ const getDatabaseAndUserFromOptions = (options) => {
   }
 };
 
+const colors = {
+  yellow: (s) => `\x1B[33m${s}\x1B[0m`,
+  green: (s) => `\x1B[32m${s}\x1B[0m`,
+  red: (s) => `\x1B[31m${s}\x1B[0m`,
+  blue: (s) => `\x1B[34m${s}\x1B[0m`,
+  bright: (s) => `\x1B[1m${s}\x1B[0m`,
+  blueBold: (s) => `\x1B[1m\x1B[34m${s}\x1B[0m`,
+  yellowBold: (s) => `\x1B[1m\x1B[33m${s}\x1B[0m`,
+  greenBold: (s) => `\x1B[1m\x1B[32m${s}\x1B[0m`,
+  pale: (s) => `\x1B[2m${s}\x1B[0m`
+};
+
+const ESC = "\x1B";
+const CSI = `${ESC}[`;
+const cursorShow = `${CSI}?25h`;
+const cursorHide = `${CSI}?25l`;
+const { stdin, stdout } = process;
+const visibleChars = (s) => s.replace(
+  // eslint-disable-next-line no-control-regex
+  /[\u001B\u009B][[\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\d\/#&.:=?%@~_]+)*|[a-zA-Z\d]+(?:;[-a-zA-Z\d\/#&.:=?%@~_]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PRZcf-ntqry=><~]))/g,
+  ""
+).length;
+const clear = (text) => {
+  const rows = text.split(/\r?\n/).reduce(
+    (rows2, line) => rows2 + 1 + Math.floor(Math.max(visibleChars(line) - 1, 0) / stdout.columns),
+    0
+  );
+  let clear2 = "";
+  for (let i = 0; i < rows; i++) {
+    clear2 += `${CSI}2K`;
+    if (i < rows - 1) {
+      clear2 += `${CSI}${i < rows - 1 ? "1A" : "G"}`;
+    }
+  }
+  return clear2;
+};
+const prompt = async ({
+  render,
+  onKeyPress,
+  validate,
+  value,
+  cursor: showCursor
+}) => {
+  stdin.resume();
+  if (stdin.isTTY)
+    stdin.setRawMode(true);
+  stdin.setEncoding("utf-8");
+  if (!showCursor)
+    stdout.write(cursorHide);
+  return new Promise((res) => {
+    let prevText;
+    const ctx = {
+      value,
+      submitted: false,
+      render() {
+        let text = (ctx.submitted ? colors.greenBold("\u2714") : colors.yellowBold("?")) + " " + render(ctx);
+        if (ctx.submitted)
+          text += "\n";
+        stdout.write(prevText ? clear(prevText) + "\r" + text : text);
+        prevText = text;
+      },
+      submit(value2) {
+        if (value2 !== void 0)
+          ctx.value = value2;
+        if (ctx.value === void 0 || validate && !(validate == null ? void 0 : validate(ctx)))
+          return;
+        ctx.submitted = true;
+        ctx.render();
+        close();
+        res(ctx.value);
+      }
+    };
+    const close = () => {
+      if (!showCursor)
+        stdout.write(cursorShow);
+      if (stdin.isTTY)
+        stdin.setRawMode(false);
+      stdin.off("data", keypress);
+      stdin.pause();
+    };
+    const keypress = (s) => {
+      if (s === "" || s === "") {
+        close == null ? void 0 : close();
+        process.exit(0);
+      }
+      if (s === "\r" || s === "\n" || s === "\r\n") {
+        ctx.submit();
+      } else {
+        onKeyPress(ctx, s);
+      }
+    };
+    stdin.on("data", keypress);
+    ctx.render();
+  });
+};
+const defaultActive = (s) => `${colors.blueBold("\u276F")} ${s}`;
+const defaultInactive = (s) => `  ${s}`;
+const promptSelect = ({
+  message,
+  options,
+  active = defaultActive,
+  inactive = defaultInactive
+}) => prompt({
+  value: 0,
+  render(ctx) {
+    let text = `${message} ${colors.pale(
+      "Use arrows or jk. Press enter to submit."
+    )}
+`;
+    for (let i = 0; i < options.length; i++) {
+      text += (ctx.value === i ? active : inactive)(options[i]) + "\n";
+    }
+    return text;
+  },
+  onKeyPress(ctx, s) {
+    ctx.value = s === "\x1B[H" ? 0 : s === "\x1B[F" ? options.length - 1 : s === "\x1B[A" || s === "k" ? ctx.value === 0 ? options.length - 1 : ctx.value - 1 : s === "\x1B[B" || s === "j" || s === "	" ? ctx.value === options.length - 1 ? 0 : ctx.value + 1 : ctx.value;
+    ctx.render();
+  }
+});
+const promptConfirm = ({
+  message
+}) => prompt({
+  value: true,
+  render(ctx) {
+    return `${colors.bright(message)}
+${ctx.submitted ? `> ${ctx.value ? colors.greenBold("Yes") : colors.yellowBold("No")}` : colors.pale(`> (Y/n)`)}
+`;
+  },
+  onKeyPress(ctx, s) {
+    let ok;
+    if (s === "y" || s === "Y")
+      ok = true;
+    else if (s === "n" || s === "N")
+      ok = false;
+    if (ok !== void 0) {
+      ctx.submit(ok);
+    }
+  }
+});
+const promptText = ({
+  message,
+  default: def = "",
+  password,
+  min
+}) => {
+  let showDefault = true;
+  let x = 0;
+  const renderValue = (ctx) => password ? "*".repeat(ctx.value.length) : ctx.value;
+  return prompt({
+    value: def,
+    cursor: true,
+    validate: (ctx) => !min || ctx.value.length >= min,
+    render(ctx) {
+      let text = `${colors.bright(message)}
+> ${ctx.submitted ? renderValue(ctx) : showDefault ? colors.pale(def) + "\b".repeat(def.length) : ctx.value}`;
+      if (ctx.submitted)
+        text += "\n";
+      return text;
+    },
+    onKeyPress(ctx, s) {
+      let value = showDefault ? "" : ctx.value;
+      if (s === "\x1B[D" && x > 0) {
+        x--;
+        stdout.write("\b");
+      } else if (s === "\x1B[C" && x < value.length) {
+        stdout.write(value[x]);
+        x++;
+      }
+      if (s !== "\x7F" && s !== "\x1B[3~" && !visibleChars(s))
+        return;
+      if (showDefault) {
+        showDefault = false;
+        stdout.write(" ".repeat(def.length) + "\b".repeat(def.length));
+      }
+      const prev = value;
+      const prevX = x;
+      if (s === "\x7F") {
+        if (x > 0) {
+          value = value.slice(0, x - 1) + value.slice(x);
+          x--;
+        }
+      } else if (s === "\x1B[3~") {
+        if (x < value.length) {
+          value = value.slice(0, x) + value.slice(x + 1);
+        }
+      } else {
+        value = value.slice(0, x) + s + value.slice(x);
+        x++;
+      }
+      ctx.value = value;
+      const spaces = prev.length - value.length;
+      stdout.write(
+        "\b".repeat(prevX) + renderValue(ctx) + (spaces > 0 ? " ".repeat(spaces) + "\b".repeat(spaces) : "") + "\b".repeat(value.length - x)
+      );
+    }
+  });
+};
+
 var __defProp$3 = Object.defineProperty;
 var __defProps$2 = Object.defineProperties;
 var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
@@ -3120,34 +3449,25 @@ const setAdapterOptions = (options, set) => {
   }
 };
 const setAdminCredentialsToOptions = async (options, create) => {
-  const confirm = await prompts([
-    {
-      message: `Would you like to share admin credentials to ${create ? "create" : "drop"} a database`,
-      type: "confirm",
-      name: "confirm",
-      initial: true
-    }
-  ]);
-  if (!confirm.confirm) {
+  const ok = await promptConfirm({
+    message: `Would you like to share admin credentials to ${create ? "create" : "drop"} a database?`
+  });
+  if (!ok) {
     return;
   }
-  const values = await prompts([
-    {
-      message: "Enter admin user:",
-      type: "text",
-      name: "user",
-      initial: "postgres",
-      min: 1
-    },
-    {
-      message: "Enter admin password:",
-      type: "password",
-      name: "password"
-    }
-  ]);
-  return setAdapterOptions(options, __spreadProps$2(__spreadValues$3({}, values), {
-    password: values.password || void 0
-  }));
+  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) => {
@@ -3279,14 +3599,14 @@ const columnsSql = ({
   information_schema._pg_datetime_precision(
     information_schema._pg_truetypid(a, t),
     information_schema._pg_truetypmod(a, t)
-  ) AS "datetimePrecision",
+  ) AS "dateTimePrecision",
   CAST(
     CASE WHEN a.attgenerated = ''
       THEN pg_get_expr(ad.adbin, ad.adrelid)
     END AS information_schema.character_data
   ) AS "default",
   NOT (a.attnotnull OR (t.typtype = 'd' AND t.typnotnull)) AS "isNullable",
-  co.collname AS "collation",
+  co.collname AS "collate",
   NULLIF(a.attcompression, '') AS compression,
   pgd.description AS "comment",
   (
@@ -3353,6 +3673,19 @@ ORDER BY relname`;
 const viewsSql = `SELECT
   nc.nspname AS "schemaName",
   c.relname AS "name",
+  (
+    SELECT COALESCE(json_agg(t.*), '[]')
+    FROM (
+      SELECT
+        ns.nspname AS "schemaName",
+        obj.relname AS "name"
+      FROM pg_class obj
+      JOIN pg_depend dep ON dep.refobjid = obj.oid
+      JOIN pg_rewrite rew ON rew.oid = dep.objid
+      JOIN pg_namespace ns ON ns.oid = obj.relnamespace
+      WHERE rew.ev_class = c.oid AND obj.oid <> c.oid
+    ) t
+  ) "deps",
   right(substring(r.ev_action from ':hasRecursive w'), 1)::bool AS "isRecursive",
   array_to_json(c.reloptions) AS "with",
   (SELECT coalesce(json_agg(t), '[]') FROM (${columnsSql({
@@ -3374,7 +3707,7 @@ const indexesSql = `SELECT
   t.relname "tableName",
   ic.relname "name",
   am.amname AS "using",
-  i.indisunique "isUnique",
+  i.indisunique "unique",
   (
     SELECT json_agg(
       (
@@ -3554,7 +3887,7 @@ JOIN pg_catalog.pg_namespace n ON n.oid = extnamespace
 const enumsSql = `SELECT
   n.nspname as "schemaName",
   t.typname as name,
-  json_agg(e.enumlabel) as values
+  json_agg(e.enumlabel ORDER BY e.enumsortorder) as values
 FROM pg_type t
 JOIN pg_enum e ON t.oid = e.enumtypid
 JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
@@ -3565,15 +3898,15 @@ const domainsSql = `SELECT
   d.typname AS "name",
   t.typname AS "type",
   s.nspname AS "typeSchema",
-  d.typnotnull AS "notNull",
+  NOT d.typnotnull AS "isNullable",
   d.typcategory = 'A' AS "isArray",
   character_maximum_length AS "maxChars",
   numeric_precision AS "numericPrecision",
   numeric_scale AS "numericScale",
   datetime_precision AS "dateTimePrecision",
-  collation_name AS "collation",
+  collation_name AS "collate",
   domain_default AS "default",
-  pg_get_expr(conbin, conrelid) AS "expression"
+  pg_get_expr(conbin, conrelid) AS "check"
 FROM pg_catalog.pg_type d
 JOIN pg_catalog.pg_namespace n ON n.oid = d.typnamespace
 JOIN information_schema.domains i
@@ -3590,7 +3923,7 @@ JOIN pg_catalog.pg_namespace s ON s.oid = t.typnamespace
 LEFT JOIN pg_catalog.pg_constraint c ON c.contypid = d.oid
 WHERE d.typtype = 'd' AND ${filterSchema("n.nspname")}`;
 const collationsSql = `SELECT
-  nspname "schema",
+  nspname "schemaName",
   collname "name",
   CASE WHEN collprovider = 'i' THEN 'icu' WHEN collprovider = 'c' THEN 'libc' ELSE collprovider::text END "provider",
   collisdeterministic "deterministic",
@@ -3615,9 +3948,93 @@ const sql = `SELECT (${schemasSql}) AS "schemas", ${jsonAgg(
   "collations"
 )}`;
 async function introspectDbSchema(db) {
+  var _a;
   const data = await db.query(sql);
-  return data.rows[0];
+  const result = data.rows[0];
+  for (const domain of result.domains) {
+    nullsToUndefined(domain);
+  }
+  for (const table of result.tables) {
+    for (const column of table.columns) {
+      nullsToUndefined(column);
+      if (column.identity)
+        nullsToUndefined(column.identity);
+      if (column.compression) {
+        column.compression = column.compression === "p" ? "pglz" : "lz4";
+      }
+    }
+  }
+  for (const index of result.indexes) {
+    nullsToUndefined(index);
+    for (const column of index.columns) {
+      if (!("expression" in column))
+        continue;
+      const s = column.expression;
+      const columnR = `"?\\w+"?`;
+      const langR = `(${columnR}|'\\w+'::regconfig)`;
+      const firstColumnR = `[(]*${columnR}`;
+      const concatR = `\\|\\|`;
+      const restColumnR = ` ${concatR} ' '::text\\) ${concatR} ${columnR}\\)`;
+      const coalesceColumn = `COALESCE\\(${columnR}, ''::text\\)`;
+      const tsVectorR = `to_tsvector\\(${langR}, (${firstColumnR}|${restColumnR}|${coalesceColumn})+\\)`;
+      const weightR = `'\\w'::"char"`;
+      const setWeightR = `setweight\\(${tsVectorR}, ${weightR}\\)`;
+      const setWeightOrTsVectorR = `(${setWeightR}|${tsVectorR})`;
+      const match = s.match(
+        new RegExp(`^([\\(]*${setWeightOrTsVectorR}[\\)]*( ${concatR} )?)+$`)
+      );
+      if (!match)
+        continue;
+      let language;
+      let languageColumn;
+      const tokens = (_a = match[0].match(
+        new RegExp(
+          `setweight\\(|to_tsvector\\(${langR}|[:']?${columnR}\\(?`,
+          "g"
+        )
+      )) == null ? void 0 : _a.reduce((acc, token) => {
+        if (token === "setweight(" || token === "COALESCE(" || token[0] === ":")
+          return acc;
+        if (token.startsWith("to_tsvector(")) {
+          if (token[12] === "'") {
+            language = token.slice(13, -12);
+          } else {
+            languageColumn = token.slice(12);
+          }
+        } else if (token[0] === "'") {
+          acc.push({ kind: "weight", value: token[1] });
+        } else {
+          if (token[0] === '"')
+            token = token.slice(1, -1);
+          acc.push({ kind: "column", value: token });
+        }
+        return acc;
+      }, []);
+      if (!tokens)
+        continue;
+      index.language = language;
+      index.languageColumn = languageColumn;
+      index.tsVector = true;
+      index.columns = [];
+      for (const token of tokens) {
+        if (token.kind === "column") {
+          index.columns.push({
+            column: token.value
+          });
+        } else if (token.kind === "weight") {
+          index.columns[index.columns.length - 1].weight = token.value;
+        }
+      }
+    }
+  }
+  return result;
 }
+const nullsToUndefined = (obj) => {
+  for (const key in obj) {
+    if (obj[key] === null)
+      obj[key] = void 0;
+  }
+};
 
 var __defProp$2 = Object.defineProperty;
 var __defProps$1 = Object.defineProperties;
@@ -3638,18 +4055,6 @@ var __spreadValues$2 = (a, b) => {
   return a;
 };
 var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp$2.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols$2)
-    for (var prop of __getOwnPropSymbols$2(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum$2.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
 const matchMap = {
   s: void 0,
   f: "FULL",
@@ -3663,6 +4068,13 @@ const fkeyActionMap = {
   n: "SET NULL",
   d: "SET DEFAULT"
 };
+const makeStructureToAstCtx = (config, currentSchema) => ({
+  snakeCase: config.snakeCase,
+  unsupportedTypes: {},
+  currentSchema,
+  columnSchemaConfig: config.schemaConfig,
+  columnsByType: pqb.makeColumnsByType(config.schemaConfig)
+});
 const structureToAst = async (ctx, adapter) => {
   const ast = [];
   const data = await introspectDbSchema(adapter);
@@ -3680,42 +4092,15 @@ const structureToAst = async (ctx, adapter) => {
       type: "collation",
       action: "create"
     }, it), {
-      schema: it.schema === ctx.currentSchema ? void 0 : it.schema
+      schema: it.schemaName === ctx.currentSchema ? void 0 : it.schemaName
     }));
   }
-  const pendingTables = {};
+  const domains = makeDomainsMap(ctx, data);
   for (const table of data.tables) {
-    const key = `${table.schemaName}.${table.name}`;
-    const dependsOn = /* @__PURE__ */ new Set();
-    for (const fk of data.constraints) {
-      const { references } = fk;
-      if (!references || fk.schemaName !== table.schemaName || fk.tableName !== table.name)
-        continue;
-      const otherKey = `${references.foreignSchema}.${references.foreignTable}`;
-      if (otherKey !== key) {
-        dependsOn.add(otherKey);
-      }
-    }
-    pendingTables[key] = { table, dependsOn };
-  }
-  const domains = {};
-  for (const it of data.domains) {
-    domains[`${it.schemaName}.${it.name}`] = getColumn(ctx, data, domains, {
-      schemaName: it.schemaName,
-      name: it.name,
-      type: it.type,
-      typeSchema: it.typeSchema,
-      isArray: it.isArray,
-      isSerial: false
-    });
-  }
-  for (const key in pendingTables) {
-    const { table, dependsOn } = pendingTables[key];
-    if (!dependsOn.size) {
-      pushTableAst(ctx, ast, data, domains, table, pendingTables);
-    }
+    if (table.name === "schemaMigrations")
+      continue;
+    ast.push(tableToAst(ctx, data, table, "create", domains));
   }
-  const outerConstraints = [];
   for (const it of data.extensions) {
     ast.push({
       type: "extension",
@@ -3740,51 +4125,50 @@ const structureToAst = async (ctx, adapter) => {
       action: "create",
       schema: it.schemaName === ctx.currentSchema ? void 0 : it.schemaName,
       name: it.name,
-      baseType: domains[`${it.schemaName}.${it.name}`],
-      notNull: it.notNull,
-      collation: it.collation,
-      default: pqb.simplifyColumnDefault(it.default),
-      check: it.check ? pqb.raw({ raw: it.check }) : void 0
+      baseType: domains[`${it.schemaName}.${it.name}`]
     });
   }
-  for (const key in pendingTables) {
-    const innerConstraints = [];
-    const { table } = pendingTables[key];
+  for (const table of data.tables) {
     for (const fkey of data.constraints) {
-      if (fkey.schemaName !== table.schemaName || fkey.tableName !== table.name)
-        continue;
-      const otherKey = fkey.references && `${fkey.references.foreignSchema}.${fkey.references.foreignTable}`;
-      if (!otherKey || !pendingTables[otherKey] || otherKey === key) {
-        innerConstraints.push(fkey);
-      } else {
-        outerConstraints.push([fkey, table]);
+      if (fkey.references && fkey.tableName === table.name && fkey.schemaName === table.schemaName && checkIfIsOuterRecursiveFkey(data, table, fkey.references)) {
+        ast.push(__spreadProps$1(__spreadValues$2({}, constraintToAst(ctx, fkey)), {
+          type: "constraint",
+          action: "create",
+          tableSchema: table.schemaName === ctx.currentSchema ? void 0 : table.schemaName,
+          tableName: fkey.tableName
+        }));
       }
     }
-    pushTableAst(
-      ctx,
-      ast,
-      data,
-      domains,
-      table,
-      pendingTables,
-      innerConstraints
-    );
-  }
-  for (const [fkey, table] of outerConstraints) {
-    ast.push(__spreadProps$1(__spreadValues$2({}, constraintToAst(ctx, fkey)), {
-      type: "constraint",
-      action: "create",
-      tableSchema: table.schemaName === ctx.currentSchema ? void 0 : table.schemaName,
-      tableName: fkey.tableName
-    }));
   }
   for (const view of data.views) {
     ast.push(viewToAst(ctx, data, domains, view));
   }
   return ast;
 };
-const makeBelongsToTable = (schema, table) => (item) => item.schemaName === schema && item.tableName === table;
-const getIsSerial = (item) => {
+const makeDomainsMap = (ctx, data) => {
+  const domains = {};
+  for (const it of data.domains) {
+    const column = instantiateDbColumn(ctx, data, domains, {
+      schemaName: it.schemaName,
+      name: it.name,
+      type: it.type,
+      typeSchema: it.typeSchema,
+      isArray: it.isArray,
+      tableName: "",
+      isNullable: it.isNullable,
+      collate: it.collate,
+      default: it.default
+    });
+    if (it.check) {
+      column.data.check = {
+        sql: new pqb.RawSQL([[it.check]])
+      };
+    }
+    domains[`${it.schemaName}.${it.name}`] = column;
+  }
+  return domains;
+};
+const getDbColumnIsSerial = (item) => {
   if (item.type === "int2" || item.type === "int4" || item.type === "int8") {
     const { default: def, schemaName, tableName, name } = item;
     const seq = `${tableName}_${name}_seq`;
@@ -3794,166 +4178,104 @@ const getIsSerial = (item) => {
   }
   return false;
 };
-const getColumn = (ctx, data, domains, _a) => {
-  var _b = _a, {
-    schemaName,
-    tableName,
-    name,
-    type,
-    typeSchema,
-    isArray,
-    isSerial
-  } = _b, params = __objRest(_b, [
-    "schemaName",
-    "tableName",
-    "name",
-    "type",
-    "typeSchema",
-    "isArray",
-    "isSerial"
-  ]);
-  var _a2, _b2;
+const instantiateDbColumn = (ctx, data, domains, dbColumn) => {
+  var _a, _b, _c;
+  const isSerial = getDbColumnIsSerial(dbColumn);
+  if (isSerial) {
+    dbColumn = __spreadProps$1(__spreadValues$2({}, dbColumn), { default: void 0 });
+  }
   let column;
-  const columnType = getColumnType(type, isSerial);
-  const typeFn = ctx.columnsByType[columnType];
-  if (typeFn) {
-    column = pqb.instantiateColumn(typeFn, params);
+  const col = instantiateColumnByDbType(ctx, dbColumn.type, isSerial, dbColumn);
+  if (col) {
+    column = col;
   } else {
-    const domainColumn = domains[`${typeSchema}.${type}`];
+    const { typeSchema, type: typeName } = dbColumn;
+    const typeId = typeSchema === "pg_catalog" ? typeName : `${typeSchema}.${typeName}`;
+    const domainColumn = domains[typeId];
     if (domainColumn) {
-      column = new pqb.DomainColumn(ctx.columnSchemaConfig, type).as(domainColumn);
+      column = new pqb.DomainColumn(ctx.columnSchemaConfig, typeId).as(
+        domainColumn
+      );
     } else {
       const enumType = data.enums.find(
-        (item) => item.name === type && item.schemaName === typeSchema
+        (x) => x.name === typeName && x.schemaName === typeSchema
       );
       if (enumType) {
         column = new pqb.EnumColumn(
           ctx.columnSchemaConfig,
-          type,
+          typeId,
           enumType.values,
           ctx.columnSchemaConfig.type
         );
       } else {
-        column = new pqb.CustomTypeColumn(ctx.columnSchemaConfig, type);
-        ((_b2 = (_a2 = ctx.unsupportedTypes)[type]) != null ? _b2 : _a2[type] = []).push(
-          `${schemaName}${tableName ? `.${tableName}` : ""}.${name}`
+        column = new pqb.CustomTypeColumn(ctx.columnSchemaConfig, typeId);
+        ((_c = (_a = ctx.unsupportedTypes)[_b = dbColumn.type]) != null ? _c : _a[_b] = []).push(
+          `${dbColumn.schemaName}${dbColumn.tableName ? `.${dbColumn.tableName}` : ""}.${dbColumn.name}`
         );
       }
     }
   }
-  return isArray ? new pqb.ArrayColumn(
+  column.data.name = void 0;
+  return dbColumn.isArray ? new pqb.ArrayColumn(
     ctx.columnSchemaConfig,
     column,
     ctx.columnSchemaConfig.type
   ) : column;
 };
-const getColumnType = (type, isSerial) => {
-  if (!isSerial)
-    return type;
-  return type === "int2" ? "smallserial" : type === "int4" ? "serial" : "bigserial";
+const instantiateColumnByDbType = (ctx, type, isSerial, params) => {
+  const columnFn = ctx.columnsByType[!isSerial ? type : type === "int2" ? "smallserial" : type === "int4" ? "serial" : "bigserial"];
+  return columnFn ? pqb.instantiateColumn(columnFn, params) : void 0;
 };
-const pushTableAst = (ctx, ast, data, domains, table, pendingTables, innerConstraints = data.constraints) => {
-  const { schemaName, name: tableName, columns } = table;
-  const key = `${schemaName}.${table.name}`;
-  delete pendingTables[key];
-  if (tableName === "schemaMigrations")
-    return;
-  const belongsToTable = makeBelongsToTable(schemaName, tableName);
-  let primaryKey;
-  for (const item of data.constraints) {
-    if (belongsToTable(item) && item.primaryKey)
-      primaryKey = { columns: item.primaryKey, name: item.name };
-  }
-  const tableIndexes = data.indexes.filter(belongsToTable);
-  const tableConstraints = innerConstraints.reduce(
-    (acc, item) => {
-      var _a;
-      const { references, check } = item;
-      if (belongsToTable(item) && (references || check && !isColumnCheck(item))) {
-        const constraint = {
-          references: references ? {
-            columns: references.columns,
-            fnOrTable: getReferencesTable(ctx, references),
-            foreignColumns: references.foreignColumns,
-            options: {
-              match: matchMap[references.match],
-              onUpdate: fkeyActionMap[references.onUpdate],
-              onDelete: fkeyActionMap[references.onDelete]
-            }
-          } : void 0,
-          check: check ? pqb.raw({ raw: check.expression }) : void 0
-        };
-        const name = item.name && item.name !== getConstraintName(tableName, constraint) ? item.name : void 0;
-        if (name) {
-          constraint.name = name;
-          if ((_a = constraint.references) == null ? void 0 : _a.options) {
-            constraint.references.options.name = name;
-          }
-        }
-        acc.push(constraint);
-      }
-      return acc;
-    },
-    []
-  );
-  const columnChecks = innerConstraints.reduce((acc, item) => {
-    if (belongsToTable(item) && isColumnCheck(item)) {
-      acc[item.check.columns[0]] = item.check.expression;
-    }
-    return acc;
-  }, {});
-  const shape = makeColumnsShape(
-    ctx,
-    data,
-    domains,
-    tableName,
-    columns,
-    primaryKey,
-    tableIndexes,
-    tableConstraints,
-    columnChecks
-  );
-  ast.push({
+const tableToAst = (ctx, data, table, action, domains) => {
+  const { schemaName, name: tableName } = table;
+  const tableData = getDbStructureTableData(data, table);
+  const { primaryKey, indexes, constraints } = tableData;
+  return {
     type: "table",
-    action: "create",
+    action,
     schema: schemaName === ctx.currentSchema ? void 0 : schemaName,
     comment: table.comment,
     name: tableName,
-    shape,
-    noPrimaryKey: primaryKey ? "error" : "ignore",
-    primaryKey: primaryKey && primaryKey.columns.length > 1 ? {
-      columns: primaryKey.columns,
-      options: primaryKey.name === `${tableName}_pkey` ? void 0 : { name: primaryKey.name }
-    } : void 0,
-    indexes: tableIndexes.filter(
-      (index) => index.columns.length > 1 || index.columns.some((it) => "expression" in it)
-    ).map((index) => ({
-      columns: index.columns.map((it) => __spreadProps$1(__spreadValues$2({}, "column" in it ? { column: it.column } : { expression: it.expression }), {
-        collate: it.collate,
-        opclass: it.opclass,
-        order: it.order
-      })),
-      options: {
-        name: index.name !== getIndexName(tableName, index.columns) ? index.name : void 0,
-        using: index.using === "btree" ? void 0 : index.using,
-        unique: index.isUnique,
-        include: index.include,
-        nullsNotDistinct: index.nullsNotDistinct,
-        with: index.with,
-        tablespace: index.tablespace,
-        where: index.where
+    shape: makeDbStructureColumnsShape(ctx, data, domains, table, tableData),
+    noPrimaryKey: tableData.primaryKey ? "error" : "ignore",
+    primaryKey: primaryKey && primaryKey.columns.length > 1 ? primaryKey : void 0,
+    indexes: indexes.reduce((acc, index) => {
+      if (index.columns.length > 1 || index.columns.some((it) => "expression" in it)) {
+        acc.push({
+          columns: index.columns.map((it) => __spreadProps$1(__spreadValues$2({}, "column" in it ? { column: it.column } : { expression: it.expression }), {
+            collate: it.collate,
+            opclass: it.opclass,
+            order: it.order
+          })),
+          options: makeIndexOptions(tableName, index)
+        });
       }
-    })),
-    constraints: tableConstraints.filter(
-      (it) => pqb.getConstraintKind(it) === "constraint" || !isColumnFkey(it)
-    )
-  });
-  for (const otherKey in pendingTables) {
-    const item = pendingTables[otherKey];
-    if (item.dependsOn.delete(key) && item.dependsOn.size === 0) {
-      pushTableAst(ctx, ast, data, domains, item.table, pendingTables);
-    }
-  }
+      return acc;
+    }, []),
+    constraints: constraints.reduce((acc, it) => {
+      var _a;
+      if (it.check && it.references || it.check && ((_a = it.check.columns) == null ? void 0 : _a.length) !== 1 || it.references && it.references.columns.length !== 1 && !checkIfIsOuterRecursiveFkey(data, table, it.references)) {
+        acc.push(dbConstraintToTableConstraint(ctx, table, it));
+      }
+      return acc;
+    }, [])
+  };
+};
+const getDbStructureTableData = (data, { name, schemaName }) => {
+  const constraints = data.constraints.filter(
+    (c) => c.tableName === name && c.schemaName === schemaName
+  );
+  const primaryKey = constraints.find((c) => c.primaryKey);
+  return {
+    primaryKey: (primaryKey == null ? void 0 : primaryKey.primaryKey) ? {
+      columns: primaryKey.primaryKey,
+      options: primaryKey.name === `${name}_pkey` ? void 0 : { name: primaryKey.name }
+    } : void 0,
+    indexes: data.indexes.filter(
+      (it) => it.tableName === name && it.schemaName === schemaName
+    ),
+    constraints
+  };
 };
 const constraintToAst = (ctx, item) => {
   var _a;
@@ -3995,12 +4317,8 @@ const isColumnCheck = (it) => {
   var _a, _b;
   return !it.references && ((_b = (_a = it.check) == null ? void 0 : _a.columns) == null ? void 0 : _b.length) === 1;
 };
-const isColumnFkey = (it) => {
-  var _a;
-  return !it.check && ((_a = it.references) == null ? void 0 : _a.columns.length) === 1;
-};
 const viewToAst = (ctx, data, domains, view) => {
-  const shape = makeColumnsShape(ctx, data, domains, view.name, view.columns);
+  const shape = makeDbStructureColumnsShape(ctx, data, domains, view);
   const options = {};
   if (view.isRecursive)
     options.recursive = true;
@@ -4019,255 +4337,852 @@ const viewToAst = (ctx, data, domains, view) => {
     name: view.name,
     shape,
     sql: pqb.raw({ raw: view.sql }),
-    options
+    options,
+    deps: view.deps
   };
 };
-const makeColumnsShape = (ctx, data, domains, tableName, columns, primaryKey, indexes, constraints, checks) => {
-  var _a, _b;
+const makeDbStructureColumnsShape = (ctx, data, domains, table, tableData) => {
   const shape = {};
-  for (let item of columns) {
-    const isSerial = getIsSerial(item);
-    if (isSerial) {
-      item = __spreadProps$1(__spreadValues$2({}, item), { default: void 0 });
-    }
-    let column = getColumn(ctx, data, domains, __spreadProps$1(__spreadValues$2({}, item), {
-      type: item.type,
-      isArray: item.isArray,
-      isSerial
-    }));
-    if (item.identity) {
-      column.data.identity = item.identity;
-      if (!item.identity.always)
-        (_a = column.data.identity) == null ? true : delete _a.always;
+  const checks = tableData ? getDbTableColumnsChecks(tableData) : void 0;
+  for (const item of table.columns) {
+    const [key, column] = dbColumnToAst(
+      ctx,
+      data,
+      domains,
+      table.name,
+      item,
+      table,
+      tableData,
+      checks
+    );
+    shape[key] = column;
+  }
+  return shape;
+};
+const getDbTableColumnsChecks = (tableData) => tableData.constraints.reduce((acc, item) => {
+  if (isColumnCheck(item)) {
+    acc[item.check.columns[0]] = item.check.expression;
+  }
+  return acc;
+}, {});
+const dbColumnToAst = (ctx, data, domains, tableName, item, table, tableData, checks) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  let column = instantiateDbColumn(ctx, data, domains, item);
+  if (item.identity) {
+    column.data.identity = item.identity;
+    if (!item.identity.always)
+      (_a = column.data.identity) == null ? true : delete _a.always;
+  }
+  if (((_c = (_b = tableData == null ? void 0 : tableData.primaryKey) == null ? void 0 : _b.columns) == null ? void 0 : _c.length) === 1 && ((_d = tableData == null ? void 0 : tableData.primaryKey) == null ? void 0 : _d.columns[0]) === item.name) {
+    column = column.primaryKey();
+  }
+  if (tableData == null ? void 0 : tableData.indexes) {
+    const columnIndexes = tableData == null ? void 0 : tableData.indexes.filter(
+      (it) => it.columns.length === 1 && "column" in it.columns[0] && it.columns[0].column === item.name
+    );
+    for (const index of columnIndexes) {
+      const options = index.columns[0];
+      column = column.index(__spreadValues$2({
+        collate: options.collate,
+        opclass: options.opclass,
+        order: options.order
+      }, makeIndexOptions(tableName, index)));
     }
-    if (((_b = primaryKey == null ? void 0 : primaryKey.columns) == null ? void 0 : _b.length) === 1 && (primaryKey == null ? void 0 : primaryKey.columns[0]) === item.name) {
-      column = column.primaryKey();
+  }
+  if (table) {
+    for (const it of data.constraints) {
+      if (it.tableName !== table.name || it.schemaName !== table.schemaName || it.check || ((_e = it.references) == null ? void 0 : _e.columns.length) !== 1 || it.references.columns[0] !== item.name || checkIfIsOuterRecursiveFkey(data, table, it.references)) {
+        continue;
+      }
+      const c = dbConstraintToTableConstraint(ctx, table, it);
+      column = column.foreignKey(
+        (_f = c.references) == null ? void 0 : _f.fnOrTable,
+        it.references.foreignColumns[0],
+        (_g = c.references) == null ? void 0 : _g.options
+      );
+    }
+  }
+  const check = checks == null ? void 0 : checks[item.name];
+  if (check) {
+    column.data.check = {
+      sql: new pqb.RawSQL([[check]])
+    };
+  }
+  const camelCaseName = orchidCore.toCamelCase(item.name);
+  if (ctx.snakeCase) {
+    const snakeCaseName = orchidCore.toSnakeCase(camelCaseName);
+    if (snakeCaseName !== item.name)
+      column.data.name = item.name;
+  } else if (camelCaseName !== item.name) {
+    column.data.name = item.name;
+  }
+  return [camelCaseName, column];
+};
+const dbConstraintToTableConstraint = (ctx, table, item) => {
+  var _a;
+  const { references, check } = item;
+  const constraint = {
+    references: references ? {
+      columns: references.columns,
+      fnOrTable: getReferencesTable(ctx, references),
+      foreignColumns: references.foreignColumns,
+      options: {
+        match: matchMap[references.match],
+        onUpdate: fkeyActionMap[references.onUpdate],
+        onDelete: fkeyActionMap[references.onDelete]
+      }
+    } : void 0,
+    check: check ? pqb.raw({ raw: check.expression }) : void 0
+  };
+  const name = item.name && item.name !== getConstraintName(table.name, constraint) ? item.name : void 0;
+  if (name) {
+    constraint.name = name;
+    if ((_a = constraint.references) == null ? void 0 : _a.options) {
+      constraint.references.options.name = name;
     }
+  }
+  return constraint;
+};
+const makeIndexOptions = (tableName, index) => {
+  return {
+    name: index.name !== getIndexName(tableName, index.columns) ? index.name : void 0,
+    using: index.using === "btree" ? void 0 : index.using,
+    unique: index.unique || void 0,
+    include: index.include,
+    nullsNotDistinct: index.nullsNotDistinct || void 0,
+    with: index.with,
+    tablespace: index.tablespace,
+    where: index.where
+  };
+};
+const checkIfIsOuterRecursiveFkey = (data, table, references) => {
+  var _a;
+  const referencesId = `${references.foreignSchema}.${references.foreignTable}`;
+  const tableId = `${table.schemaName}.${table.name}`;
+  for (const other of data.tables) {
+    const id = `${other.schemaName}.${other.name}`;
+    if (referencesId === id) {
+      for (const c of data.constraints) {
+        if (c.tableName === other.name && c.schemaName === other.schemaName && ((_a = c.references) == null ? void 0 : _a.foreignTable) === table.name && c.references.foreignSchema === table.schemaName && tableId < id) {
+          return true;
+        }
+      }
+      break;
+    }
+  }
+  return false;
+};
+
+const astToGenerateItems = (asts, currentSchema) => {
+  return asts.map((ast) => astToGenerateItem(ast, currentSchema));
+};
+const astToGenerateItem = (ast, currentSchema) => {
+  var _a, _b, _c, _d, _e;
+  const add = [];
+  const drop = [];
+  const deps = [];
+  const typeSchemaCache = /* @__PURE__ */ new Map();
+  const resolveType = (type) => {
+    let dep = typeSchemaCache.get(type);
+    if (!dep) {
+      const [schema = currentSchema, name] = getSchemaAndTableFromName(type);
+      dep = `${schema}.${name}`;
+      typeSchemaCache.set(type, dep);
+    }
+    return dep;
+  };
+  switch (ast.type) {
+    case "table":
+    case "changeTable":
+    case "view": {
+      const schema = (_a = ast.schema) != null ? _a : currentSchema;
+      const table = `${schema}.${ast.name}`;
+      if (ast.type === "table" || ast.type === "view") {
+        const keys = ast.action === "create" ? add : drop;
+        keys.push(table);
+        deps.push(schema);
+        const columns = Object.entries(ast.shape).map(
+          ([name, column]) => [keys, name, { column }]
+        );
+        analyzeTableColumns(
+          currentSchema,
+          schema,
+          table,
+          deps,
+          resolveType,
+          columns
+        );
+        if (ast.type === "table") {
+          analyzeTableData(currentSchema, schema, table, keys, deps, ast);
+        } else {
+          deps.push(
+            ...ast.deps.map(({ schemaName, name }) => `${schemaName}.${name}`)
+          );
+        }
+      } else {
+        deps.push(table);
+        const columns = [];
+        for (const name in ast.shape) {
+          const arr = orchidCore.toArray(ast.shape[name]);
+          for (const item of arr) {
+            if (item.type === "add") {
+              columns.push([add, name, { column: item.item }]);
+            } else if (item.type === "drop") {
+              columns.push([drop, name, { column: item.item }]);
+            } else if (item.type === "change") {
+              columns.push([add, name, item.to]);
+              columns.push([drop, name, item.from]);
+            }
+          }
+        }
+        analyzeTableColumns(
+          currentSchema,
+          schema,
+          table,
+          deps,
+          resolveType,
+          columns
+        );
+        analyzeTableData(currentSchema, schema, table, add, deps, ast.add);
+        analyzeTableData(currentSchema, schema, table, drop, deps, ast.drop);
+      }
+      break;
+    }
+    case "renameType": {
+      const { fromSchema = currentSchema, toSchema = currentSchema } = ast;
+      add.push(`${toSchema}.${ast.to}`);
+      drop.push(`${fromSchema}.${ast.from}`);
+      deps.push(fromSchema, toSchema);
+      break;
+    }
+    case "schema": {
+      (ast.action === "create" ? add : drop).push(ast.name);
+      break;
+    }
+    case "renameSchema": {
+      drop.push(ast.from);
+      add.push(ast.to);
+      break;
+    }
+    case "enum":
+    case "collation":
+    case "extension": {
+      const schema = (_b = ast.schema) != null ? _b : currentSchema;
+      (ast.action === "create" ? add : drop).push(`${schema}.${ast.name}`);
+      deps.push(schema);
+      break;
+    }
+    case "enumValues":
+    case "renameEnumValues":
+    case "changeEnumValues": {
+      const schema = (_c = ast.schema) != null ? _c : currentSchema;
+      deps.push(schema, `${schema}.${ast.name}`);
+      break;
+    }
+    case "domain": {
+      const schema = (_d = ast.schema) != null ? _d : currentSchema;
+      (ast.action === "create" ? add : drop).push(`${schema}.${ast.name}`);
+      const column = ast.baseType;
+      deps.push(schema, resolveType(column.dataType));
+      if (column.data.collate)
+        deps.push(column.data.collate);
+      break;
+    }
+    case "constraint": {
+      const { tableSchema = currentSchema, tableName } = ast;
+      const name = `${tableSchema}.${(_e = ast.name) != null ? _e : getConstraintName(tableName, ast)}`;
+      (ast.action === "create" ? add : drop).push(name);
+      deps.push(tableSchema, `${tableSchema}.${tableName}`);
+      break;
+    }
+    case "renameTableItem": {
+      const { tableSchema = currentSchema, tableName } = ast;
+      drop.push(ast.from);
+      add.push(ast.to);
+      deps.push(tableSchema, `${tableSchema}.${tableName}`);
+      break;
+    }
+    default:
+      exhaustive();
+  }
+  return {
+    ast,
+    add: new Set(add),
+    drop: new Set(drop),
+    deps: new Set(deps)
+  };
+};
+const analyzeTableColumns = (currentSchema, schema, table, deps, resolveType, columns) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  for (const [keys, name, change] of columns) {
+    const { column } = change;
+    if (column) {
+      let c = column;
+      while (c.dataType === "array") {
+        c = column.data.item;
+      }
+      let type;
+      if (c.dataType === "enum") {
+        type = c.enumName;
+      } else {
+        type = c.dataType;
+      }
+      deps.push(resolveType(type));
+    } else if (change.type) {
+      deps.push(resolveType(change.type));
+    }
+    const collate = (_b = (_a = change.column) == null ? void 0 : _a.data.collate) != null ? _b : change.collate;
+    if (collate)
+      deps.push(collate);
+    const primaryKey = change.primaryKey || ((_c = change.column) == null ? void 0 : _c.data.primaryKey);
+    if (primaryKey) {
+      keys.push(`${table}_pkey`);
+    }
+    const indexes = change.indexes || ((_d = change.column) == null ? void 0 : _d.data.indexes);
     if (indexes) {
-      const columnIndexes = indexes.filter(
-        (it) => it.columns.length === 1 && "column" in it.columns[0] && it.columns[0].column === item.name
-      );
-      for (const index of columnIndexes) {
-        const options = index.columns[0];
-        column = column.index({
-          collate: options.collate,
-          opclass: options.opclass,
-          order: options.order,
-          name: index.name !== getIndexName(tableName, index.columns) ? index.name : void 0,
-          using: index.using === "btree" ? void 0 : index.using,
-          unique: index.isUnique,
-          include: index.include,
-          nullsNotDistinct: index.nullsNotDistinct,
-          with: index.with,
-          tablespace: index.tablespace,
-          where: index.where
-        });
+      for (const index of indexes) {
+        keys.push(
+          index.name ? `${schema}.${index.name}` : getIndexName(table, [
+            { column: (_f = (_e = change.column) == null ? void 0 : _e.data.name) != null ? _f : name }
+          ])
+        );
       }
     }
-    if (constraints) {
-      for (const it of constraints) {
-        if (!isColumnFkey(it) || it.references.columns[0] !== item.name)
-          continue;
-        column = column.foreignKey(
-          it.references.fnOrTable,
-          it.references.foreignColumns[0],
-          it.references.options
+    const foreignKeys = change.foreignKeys || ((_g = change.column) == null ? void 0 : _g.data.foreignKeys);
+    if (foreignKeys) {
+      for (const fkey of foreignKeys) {
+        keys.push(
+          fkey.name ? `${schema}.${fkey.name}` : getConstraintName(table, {
+            references: { columns: [(_i = (_h = change.column) == null ? void 0 : _h.data.name) != null ? _i : name] }
+          })
         );
+        const [s = currentSchema, t] = getForeignKeyTable(
+          "table" in fkey ? fkey.table : fkey.fn
+        );
+        deps.push(`${s}.${t}`);
       }
     }
-    const check = checks == null ? void 0 : checks[item.name];
-    if (check) {
-      column.data.check = pqb.raw({ raw: check });
+  }
+};
+const analyzeTableData = (currentSchema, schema, table, keys, deps, data) => {
+  var _a, _b;
+  if (data.primaryKey) {
+    const name = (_a = data.primaryKey.options) == null ? void 0 : _a.name;
+    keys.push(name ? `${schema}.${name}` : `${table}_pkey`);
+  }
+  if (data.indexes) {
+    for (const index of data.indexes) {
+      const name = (_b = index.options) == null ? void 0 : _b.name;
+      keys.push(
+        name ? `${schema}.${name}` : getIndexName(table, index.columns)
+      );
     }
-    const camelCaseName = orchidCore.toCamelCase(item.name);
-    if (ctx.snakeCase) {
-      const snakeCaseName = orchidCore.toSnakeCase(camelCaseName);
-      if (snakeCaseName !== item.name)
-        column.data.name = item.name;
-    } else if (camelCaseName !== item.name) {
-      column.data.name = item.name;
+  }
+  if (data.constraints) {
+    for (const constraint of data.constraints) {
+      keys.push(
+        constraint.name ? `${schema}.${constraint.name}` : getConstraintName(table, constraint)
+      );
+      if (constraint.references) {
+        const [s = currentSchema, t] = getForeignKeyTable(
+          constraint.references.fnOrTable
+        );
+        deps.push(`${s}.${t}`);
+      }
     }
-    shape[camelCaseName] = column;
   }
-  return shape;
 };
 
-const astToMigration = (config, ast) => {
-  const first = [];
-  const tablesAndViews = [];
-  const constraints = [];
-  for (const item of ast) {
-    if (item.type === "schema" && item.action === "create") {
-      first.push(createSchema(item));
-    } else if (item.type === "extension" && item.action === "create") {
-      if (first.length)
-        first.push([]);
-      first.push(...createExtension(item));
-    } else if (item.type === "enum" && item.action === "create") {
-      if (first.length)
-        first.push([]);
-      first.push(createEnum(item));
-    } else if (item.type === "domain" && item.action === "create") {
-      if (first.length)
-        first.push([]);
-      first.push(...createDomain(item));
-    } else if (item.type === "collation" && item.action === "create") {
-      if (first.length)
-        first.push([]);
-      first.push(...createCollation(item));
-    } else if (item.type === "table" && item.action === "create") {
-      tablesAndViews.push(createTable(config, item));
-    } else if (item.type === "view" && item.action === "create") {
-      tablesAndViews.push(createView(item));
-    } else if (item.type === "constraint") {
-      if (constraints.length)
-        constraints.push([]);
-      constraints.push(...createConstraint(item));
-    }
-  }
-  if (!first.length && !tablesAndViews.length && !constraints.length)
-    return;
-  let code = "";
-  if (first.length) {
-    code += `
-change(async (db) => {
-${orchidCore.codeToString(first, "  ", "  ")}
-});
-`;
+const astToMigration = (currentSchema, config, asts) => {
+  var _a, _b, _c;
+  const items = astToGenerateItems(asts, currentSchema);
+  const toBeAdded = /* @__PURE__ */ new Set();
+  const toBeDropped = /* @__PURE__ */ new Set();
+  const remainingDeps = /* @__PURE__ */ new Map();
+  const added = /* @__PURE__ */ new Set();
+  const dropped = /* @__PURE__ */ new Set();
+  const groups = [[]];
+  const cycleAdd = /* @__PURE__ */ new Set();
+  const cycleDrop = /* @__PURE__ */ new Set();
+  const cycleDeps = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    for (const add of item.add) {
+      toBeAdded.add(add);
+    }
+    for (const drop of item.drop) {
+      if (!item.add.has(drop)) {
+        toBeDropped.add(drop);
+      }
+    }
+    for (const dep of item.deps) {
+      remainingDeps.set(dep, ((_a = remainingDeps.get(dep)) != null ? _a : 0) + 1);
+    }
   }
-  if (tablesAndViews.length) {
-    for (const table of tablesAndViews) {
-      code += `
-change(async (db) => {
-${orchidCore.codeToString(table, "  ", "  ")}
-});
-`;
+  let len = items.length;
+  if (!len)
+    return;
+  for (; ; ) {
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      let satisfied = true;
+      for (const dep of item.deps) {
+        if (toBeAdded.has(dep) && !added.has(dep)) {
+          satisfied = false;
+          break;
+        }
+      }
+      if (satisfied) {
+        for (const key of item.drop) {
+          if (remainingDeps.has(key)) {
+            satisfied = false;
+            break;
+          }
+        }
+      }
+      if (satisfied) {
+        for (const key of item.add) {
+          if (toBeDropped.has(key) && !dropped.has(key)) {
+            satisfied = false;
+            break;
+          }
+        }
+      }
+      if (satisfied) {
+        for (const key of item.add) {
+          cycleAdd.add(key);
+        }
+        for (const key of item.drop) {
+          cycleDrop.add(key);
+        }
+        for (const key of item.deps) {
+          cycleDeps.set(key, ((_b = cycleDeps.get(key)) != null ? _b : 0) + 1);
+        }
+        items.splice(i, 1);
+        i--;
+        groups[groups.length - 1].push(item.ast);
+      }
     }
+    if (len === items.length) {
+      throw Object.assign(
+        new Error(
+          `Cannot satisfy migration dependencies: ${JSON.stringify(
+            items.map((item) => ({
+              ast: item.ast,
+              add: [...item.add.values()],
+              drop: [...item.drop.values()],
+              deps: [...item.deps.values()]
+            })),
+            null,
+            2
+          )}`
+        )
+      );
+    }
+    for (const add of cycleAdd) {
+      added.add(add);
+    }
+    for (const drop of cycleDrop) {
+      dropped.add(drop);
+    }
+    for (const [key, num] of cycleDeps) {
+      const set = ((_c = remainingDeps.get(key)) != null ? _c : num) - num;
+      if (set)
+        remainingDeps.set(key, set);
+      else
+        remainingDeps.delete(key);
+    }
+    len = items.length;
+    if (!len)
+      break;
+    groups.push([]);
   }
-  if (constraints.length) {
+  if (!groups[0].length)
+    return;
+  let code = "";
+  for (const group of groups) {
     code += `
 change(async (db) => {
-${orchidCore.codeToString(constraints, "  ", "  ")}
+${group.map(
+      (ast) => orchidCore.codeToString(
+        astEncoders[ast.type](ast, config, currentSchema),
+        "  ",
+        "  "
+      )
+    ).join("\n\n")}
 });
 `;
   }
-  return (importPath) => `import { change } from '${importPath}';
-${code}`;
-};
-const createSchema = (ast) => {
-  return `await db.createSchema(${orchidCore.singleQuote(ast.name)});`;
+  return code;
 };
-const createExtension = (ast) => {
-  const code = [`await db.createExtension(${orchidCore.singleQuote(ast.name)}`];
-  if (ast.schema || ast.version) {
-    orchidCore.addCode(code, ", {");
-    if (ast.schema) {
-      code.push([`schema: ${orchidCore.singleQuote(ast.schema)},`]);
+const astEncoders = {
+  table(ast, config) {
+    let code = [];
+    const result = code;
+    const hasOptions = Boolean(ast.comment || ast.noPrimaryKey === "ignore");
+    if (hasOptions) {
+      orchidCore.addCode(code, `await db.${ast.action}Table(`);
+      const inner = [`${quoteSchemaTable(ast)},`];
+      code.push(inner);
+      code = inner;
+      const options = [];
+      if (ast.comment)
+        options.push(`comment: ${JSON.stringify(ast.comment)},`);
+      if (ast.noPrimaryKey === "ignore")
+        options.push(`noPrimaryKey: true,`);
+      code.push("{", options, "},", "(t) => ({");
+    } else {
+      orchidCore.addCode(
+        code,
+        `await db.${ast.action}Table(${quoteSchemaTable(ast)}, (t) => ({`
+      );
+    }
+    const timestamps = getHasTimestamps(
+      config,
+      ast.shape.createdAt,
+      ast.shape.updatedAt
+    );
+    for (const key in ast.shape) {
+      if (timestamps.hasAnyTimestamps && (key === "createdAt" || key === "updatedAt"))
+        continue;
+      const line = [`${orchidCore.quoteObjectKey(key)}: `];
+      for (const part of ast.shape[key].toCode("t", true)) {
+        orchidCore.addCode(line, part);
+      }
+      orchidCore.addCode(line, ",");
+      code.push(line);
+    }
+    if (timestamps.hasAnyTimestamps) {
+      code.push([`...${timestampsToCode(config, timestamps)},`]);
+    }
+    if (ast.primaryKey) {
+      code.push([pqb.primaryKeyToCode(ast.primaryKey, "t")]);
+    }
+    if (ast.indexes) {
+      for (const index of ast.indexes) {
+        code.push(pqb.indexToCode(index, "t"));
+      }
+    }
+    if (ast.constraints) {
+      for (const constraint of ast.constraints) {
+        code.push(pqb.constraintToCode(constraint, "t", true));
+      }
+    }
+    if (hasOptions) {
+      orchidCore.addCode(code, "}),");
+      orchidCore.addCode(result, ");");
+    } else {
+      orchidCore.addCode(result, "}));");
+    }
+    return result;
+  },
+  changeTable(ast, config, currentSchema) {
+    let code = [];
+    const result = code;
+    const schemaTable = quoteSchemaTable({
+      schema: ast.schema === currentSchema ? void 0 : ast.schema,
+      name: ast.name
+    });
+    const { comment } = ast;
+    if (comment !== void 0) {
+      orchidCore.addCode(code, `await db.changeTable(`);
+      const inner = [
+        `${schemaTable},`,
+        `{ comment: ${JSON.stringify(ast.comment)} },`,
+        "(t) => ({"
+      ];
+      code.push(inner);
+      code = inner;
+    } else {
+      orchidCore.addCode(code, `await db.changeTable(${schemaTable}, (t) => ({`);
+    }
+    const [addTimestamps, dropTimestamps] = ["add", "drop"].map(
+      (type) => {
+        var _a, _b;
+        return getHasTimestamps(
+          config,
+          ast.shape.createdAt && "type" in ast.shape.createdAt && ((_a = ast.shape.createdAt) == null ? void 0 : _a.type) === type ? ast.shape.createdAt.item : void 0,
+          ast.shape.updatedAt && "type" in ast.shape.updatedAt && ((_b = ast.shape.updatedAt) == null ? void 0 : _b.type) === type ? ast.shape.updatedAt.item : void 0
+        );
+      }
+    );
+    for (const key in ast.shape) {
+      const changes = orchidCore.toArray(ast.shape[key]);
+      for (const change of changes) {
+        if (change.type === "add" || change.type === "drop") {
+          if ((addTimestamps.hasAnyTimestamps || dropTimestamps.hasAnyTimestamps) && (key === "createdAt" || key === "updatedAt"))
+            continue;
+          const recreate = changes.length > 1;
+          const line = [
+            recreate ? `...t.${change.type}(t.name(${orchidCore.singleQuote(key)})` : `${orchidCore.quoteObjectKey(key)}: t.${change.type}(`
+          ];
+          const columnCode = change.item.toCode("t", true);
+          for (let i = 0; i < columnCode.length; i++) {
+            let part = columnCode[i];
+            if (recreate && !i)
+              part = part.slice(1);
+            orchidCore.addCode(line, part);
+          }
+          orchidCore.addCode(line, "),");
+          code.push(line);
+        } else if (change.type === "change") {
+          if (!change.from.column || !change.to.column)
+            continue;
+          const line = [
+            `${orchidCore.quoteObjectKey(key)}: t${change.name ? `.name(${orchidCore.singleQuote(change.name)})` : ""}.change(`
+          ];
+          for (const part of change.from.column.toCode("t", true)) {
+            orchidCore.addCode(line, part);
+          }
+          orchidCore.addCode(line, ", ");
+          for (const part of change.to.column.toCode("t", true)) {
+            orchidCore.addCode(line, part);
+          }
+          if (change.using) {
+            orchidCore.addCode(line, ", {");
+            const u = [];
+            if (change.using.usingUp) {
+              u.push(`usingUp: ${change.using.usingUp.toCode("t")},`);
+            }
+            if (change.using.usingDown) {
+              u.push(`usingDown: ${change.using.usingDown.toCode("t")},`);
+            }
+            orchidCore.addCode(line, u);
+            orchidCore.addCode(line, "}");
+          }
+          orchidCore.addCode(line, "),");
+          code.push(line);
+        } else if (change.type === "rename") {
+          code.push([
+            `${orchidCore.quoteObjectKey(key)}: t.rename(${orchidCore.singleQuote(change.name)}),`
+          ]);
+        } else {
+          exhaustive(change.type);
+        }
+      }
+    }
+    for (const key of ["drop", "add"]) {
+      const timestamps = key === "add" ? addTimestamps : dropTimestamps;
+      if (timestamps.hasAnyTimestamps) {
+        orchidCore.addCode(code, [
+          `...t.${key}(${timestampsToCode(config, timestamps)}),`
+        ]);
+      }
+      const { primaryKey, indexes, constraints } = ast[key];
+      if (primaryKey) {
+        orchidCore.addCode(code, [
+          `...t.${key}(${pqb.primaryKeyInnerToCode(primaryKey, "t")}),`
+        ]);
+      }
+      if (indexes) {
+        for (const index of indexes) {
+          orchidCore.addCode(code, [`...t.${key}(`, pqb.indexInnerToCode(index, "t"), "),"]);
+        }
+      }
+      if (constraints) {
+        for (const item of constraints) {
+          orchidCore.addCode(code, [
+            `...t.${key}(`,
+            pqb.constraintInnerToCode(item, "t", true),
+            "),"
+          ]);
+        }
+      }
     }
+    if (ast.comment !== void 0) {
+      orchidCore.addCode(code, "}),");
+      orchidCore.addCode(result, ");");
+    } else {
+      orchidCore.addCode(result, "}));");
+    }
+    return result;
+  },
+  renameType(ast, _, currentSchema) {
+    var _a, _b;
+    const code = [];
+    const kind = ast.kind === "TABLE" ? "Table" : "Type";
+    if (ast.from === ast.to) {
+      orchidCore.addCode(
+        code,
+        `await db.change${kind}Schema(${orchidCore.singleQuote(ast.to)}, ${orchidCore.singleQuote(
+          (_a = ast.fromSchema) != null ? _a : currentSchema
+        )}, ${orchidCore.singleQuote((_b = ast.toSchema) != null ? _b : currentSchema)});`
+      );
+    } else {
+      orchidCore.addCode(
+        code,
+        `await db.rename${kind}(${quoteSchemaTable({
+          schema: ast.fromSchema === currentSchema ? void 0 : ast.fromSchema,
+          name: ast.from
+        })}, ${quoteSchemaTable({
+          schema: ast.toSchema === currentSchema ? void 0 : ast.toSchema,
+          name: ast.to
+        })});`
+      );
+    }
+    return code;
+  },
+  schema(ast) {
+    return `await db.${ast.action === "create" ? "createSchema" : "dropSchema"}(${orchidCore.singleQuote(ast.name)});`;
+  },
+  renameSchema(ast) {
+    return `await db.renameSchema(${orchidCore.singleQuote(ast.from)}, ${orchidCore.singleQuote(
+      ast.to
+    )});`;
+  },
+  extension(ast) {
+    const code = [
+      `await db.${ast.action}Extension(${quoteSchemaTable(ast)}`
+    ];
     if (ast.version) {
-      code.push([`version: ${orchidCore.singleQuote(ast.version)},`]);
+      orchidCore.addCode(code, ", {");
+      code.push([`version: ${orchidCore.singleQuote(ast.version)},`], "}");
     }
-    orchidCore.addCode(code, "}");
-  }
-  orchidCore.addCode(code, ");");
-  return code;
-};
-const createEnum = (ast) => {
-  return `await db.createEnum(${quoteSchemaTable(ast)}, [${ast.values.map(orchidCore.singleQuote).join(", ")}]);`;
-};
-const createDomain = (ast) => {
-  const code = [
-    `await db.createDomain(${quoteSchemaTable(
+    orchidCore.addCode(code, ");");
+    return code;
+  },
+  enum(ast) {
+    return `await db.${ast.action === "create" ? "createEnum" : "dropEnum"}(${quoteSchemaTable(ast)}, [${ast.values.map(orchidCore.singleQuote).join(", ")}]);`;
+  },
+  enumValues(ast) {
+    return `await db.${ast.action}EnumValues(${quoteSchemaTable(
       ast
-    )}, (t) => ${ast.baseType.toCode("t")}`
-  ];
-  if (ast.notNull || ast.collation || ast.default || ast.check) {
-    const props = [];
-    if (ast.notNull)
-      props.push(`notNull: true,`);
-    if (ast.collation)
-      props.push(`collation: ${orchidCore.singleQuote(ast.collation)},`);
-    if (ast.default)
-      props.push(`default: ${ast.default.toCode("db")},`);
-    if (ast.check)
-      props.push(`check: ${ast.check.toCode("db")},`);
-    orchidCore.addCode(code, ", {");
-    code.push(props);
-    orchidCore.addCode(code, "}");
-  }
-  orchidCore.addCode(code, ");");
-  return code;
-};
-const createCollation = (ast) => {
-  const params = [];
-  if (ast.locale)
-    params.push(`locale: '${ast.locale}',`);
-  if (ast.lcCollate)
-    params.push(`lcCollate: '${ast.lcCollate}',`);
-  if (ast.lcCType)
-    params.push(`lcCType: '${ast.lcCType}',`);
-  if (ast.provider)
-    params.push(`provider: '${ast.provider}',`);
-  if (ast.deterministic)
-    params.push(`deterministic: ${ast.deterministic},`);
-  if (ast.version)
-    params.push(`version: '${ast.version}',`);
-  return [
-    `await db.createCollation(${quoteSchemaTable(ast)}, {`,
-    params,
-    "});"
-  ];
-};
-const createTable = (config, ast) => {
-  const code = [];
-  orchidCore.addCode(code, `await db.createTable(${quoteSchemaTable(ast)}, (t) => ({`);
-  const timestamps = getTimestampsInfo(config, ast, pqb.TimestampTZColumn);
-  const timestampsNoTZ = getTimestampsInfo(config, ast, pqb.TimestampTZColumn);
-  const hasAnyTimestamps = timestamps.hasTimestamps || timestampsNoTZ.hasTimestamps;
-  const hasAnyCamelCaseTimestamps = timestamps.camelCaseTimestamps || timestampsNoTZ.camelCaseTimestamps;
-  for (const key in ast.shape) {
-    if (hasAnyTimestamps && (key === "createdAt" || key === "updatedAt"))
-      continue;
-    const line = [`${orchidCore.quoteObjectKey(key)}: `];
-    for (const part of ast.shape[key].toCode("t", true)) {
-      orchidCore.addCode(line, part);
+    )}, [${ast.values.map(orchidCore.singleQuote).join(", ")}]);`;
+  },
+  renameEnumValues(ast) {
+    return `await db.renameEnumValues(${quoteSchemaTable(
+      ast
+    )}, { ${Object.entries(ast.values).map(([from, to]) => `${orchidCore.quoteObjectKey(from)}: ${orchidCore.singleQuote(to)}`).join(", ")} });`;
+  },
+  changeEnumValues(ast) {
+    return `await db.changeEnumValues(${quoteSchemaTable(
+      ast
+    )}, [${ast.fromValues.map(orchidCore.singleQuote).join(", ")}], [${ast.toValues.map(orchidCore.singleQuote).join(", ")}]);`;
+  },
+  domain(ast) {
+    return `await db.${ast.action}Domain(${quoteSchemaTable(
+      ast
+    )}, (t) => ${ast.baseType.toCode("t")});`;
+  },
+  collation(ast) {
+    const params = [];
+    if (ast.locale)
+      params.push(`locale: '${ast.locale}',`);
+    if (ast.lcCollate)
+      params.push(`lcCollate: '${ast.lcCollate}',`);
+    if (ast.lcCType)
+      params.push(`lcCType: '${ast.lcCType}',`);
+    if (ast.provider)
+      params.push(`provider: '${ast.provider}',`);
+    if (ast.deterministic)
+      params.push(`deterministic: ${ast.deterministic},`);
+    if (ast.version)
+      params.push(`version: '${ast.version}',`);
+    return [
+      `await db.createCollation(${quoteSchemaTable(ast)}, {`,
+      params,
+      "});"
+    ];
+  },
+  constraint(ast) {
+    const kind = pqb.getConstraintKind(ast);
+    const table = quoteSchemaTable({
+      schema: ast.tableSchema,
+      name: ast.tableName
+    });
+    if (kind === "foreignKey" && ast.references) {
+      return [
+        `await db.addForeignKey(`,
+        [`${table},`, ...pqb.referencesArgsToCode(ast.references, ast.name, true)],
+        ");"
+      ];
     }
-    orchidCore.addCode(line, ",");
-    code.push(line);
-  }
-  if (hasAnyTimestamps) {
-    const key = timestamps.hasTimestamps ? "timestamps" : "timestampsNoTZ";
-    code.push([
-      `...t.${hasAnyCamelCaseTimestamps || config.snakeCase ? key : `${key}SnakeCase`}(),`
-    ]);
-  }
-  if (ast.primaryKey) {
-    code.push([pqb.primaryKeyToCode(ast.primaryKey, "t")]);
-  }
-  if (ast.indexes) {
-    for (const index of ast.indexes) {
-      code.push(pqb.indexToCode(index, "t"));
+    if (kind === "check" && ast.check) {
+      return [`await db.addCheck(${table}, ${ast.check.toCode("t")});`];
     }
-  }
-  if (ast.constraints) {
-    for (const constraint of ast.constraints) {
-      code.push(pqb.constraintToCode(constraint, "t"));
+    return [
+      `await db.addConstraint(${table}, {`,
+      pqb.constraintPropsToCode("t", ast, true),
+      "});"
+    ];
+  },
+  renameTableItem(ast) {
+    return [
+      `await db.rename${ast.kind === "INDEX" ? "Index" : "Constraint"}(${quoteSchemaTable({
+        schema: ast.tableSchema,
+        name: ast.tableName
+      })}, ${orchidCore.singleQuote(ast.from)}, ${orchidCore.singleQuote(ast.to)});`
+    ];
+  },
+  view(ast) {
+    const code = [`await db.createView(${quoteSchemaTable(ast)}`];
+    const options = [];
+    if (ast.options.recursive)
+      options.push("recursive: true,");
+    const w = ast.options.with;
+    if (w == null ? void 0 : w.checkOption)
+      options.push(`checkOption: '${w.checkOption}',`);
+    if (w == null ? void 0 : w.securityBarrier)
+      options.push(`securityBarrier: ${w.securityBarrier},`);
+    if (w == null ? void 0 : w.securityInvoker)
+      options.push(`securityInvoker: ${w.securityInvoker},`);
+    if (options.length) {
+      orchidCore.addCode(code, ", {");
+      code.push(options, "}");
+    }
+    orchidCore.addCode(code, ", ");
+    if (!ast.sql._values) {
+      const raw = ast.sql._sql;
+      let sql;
+      if (typeof raw === "string") {
+        sql = raw;
+      } else {
+        sql = "";
+        const parts = raw[0];
+        const last = parts.length - 1;
+        for (let i = 0; i < last; i++) {
+          sql += parts[i] + `\${${raw[i + 1]}}`;
+        }
+        sql += parts[last];
+      }
+      orchidCore.addCode(code, orchidCore.backtickQuote(sql));
+    } else {
+      orchidCore.addCode(code, ast.sql.toCode("db"));
     }
+    orchidCore.addCode(code, ");");
+    return code;
   }
-  orchidCore.addCode(code, "}));");
-  return code;
 };
 const isTimestamp = (column, type) => {
   if (!column)
     return false;
   const { default: def } = column.data;
-  return column instanceof type && !column.data.isNullable && def && typeof def === "object" && orchidCore.isRawSQL(def) && def._sql === "now()";
+  return Boolean(
+    column instanceof type && !column.data.isNullable && def && typeof def === "object" && orchidCore.isRawSQL(def) && (typeof def._sql === "object" ? def._sql[0][0] : def._sql) === "now()"
+  );
 };
-const getTimestampsInfo = (config, ast, type) => {
-  var _a, _b, _c, _d, _e, _f;
-  let hasTimestamps = isTimestamp(ast.shape.createdAt, type) && isTimestamp(ast.shape.updatedAt, type);
-  const camelCaseTimestamps = !config.snakeCase && hasTimestamps && !((_a = ast.shape.createdAt) == null ? void 0 : _a.data.name) && !((_b = ast.shape.updatedAt) == null ? void 0 : _b.data.name);
-  const snakeCaseTimestamps = hasTimestamps && !camelCaseTimestamps && (!config.snakeCase && ((_c = ast.shape.createdAt) == null ? void 0 : _c.data.name) === "created_at" && ((_d = ast.shape.updatedAt) == null ? void 0 : _d.data.name) === "updated_at" || config.snakeCase && !((_e = ast.shape.createdAt) == null ? void 0 : _e.data.name) && !((_f = ast.shape.updatedAt) == null ? void 0 : _f.data.name));
+const getHasTimestamps = (config, createdAt, updatedAt) => {
+  const timestamps = getTimestampsInfo(
+    config,
+    createdAt,
+    updatedAt,
+    pqb.TimestampTZColumn
+  );
+  const timestampsNoTZ = getTimestampsInfo(
+    config,
+    createdAt,
+    updatedAt,
+    pqb.TimestampColumn
+  );
+  return {
+    hasTZTimestamps: timestamps.hasTimestamps,
+    hasAnyTimestamps: timestamps.hasTimestamps || timestampsNoTZ.hasTimestamps,
+    hasAnyCamelCaseTimestamps: timestamps.camelCaseTimestamps || timestampsNoTZ.camelCaseTimestamps
+  };
+};
+const getTimestampsInfo = (config, createdAt, updatedAt, type) => {
+  let hasTimestamps = isTimestamp(createdAt, type) && isTimestamp(updatedAt, type);
+  const camelCaseTimestamps = !config.snakeCase && hasTimestamps && !(createdAt == null ? void 0 : createdAt.data.name) && !(updatedAt == null ? void 0 : updatedAt.data.name);
+  const snakeCaseTimestamps = hasTimestamps && !camelCaseTimestamps && (!config.snakeCase && (createdAt == null ? void 0 : createdAt.data.name) === "created_at" && (updatedAt == null ? void 0 : updatedAt.data.name) === "updated_at" || config.snakeCase && !(createdAt == null ? void 0 : createdAt.data.name) && !(updatedAt == null ? void 0 : updatedAt.data.name));
   if (!camelCaseTimestamps && !snakeCaseTimestamps) {
     hasTimestamps = false;
   }
@@ -4277,81 +5192,19 @@ const getTimestampsInfo = (config, ast, type) => {
     snakeCaseTimestamps
   };
 };
-const createConstraint = (item) => {
-  const kind = pqb.getConstraintKind(item);
-  const table = quoteSchemaTable({
-    schema: item.tableSchema,
-    name: item.tableName
-  });
-  if (kind === "foreignKey" && item.references) {
-    return [
-      `await db.addForeignKey(`,
-      [`${table},`, ...pqb.referencesArgsToCode(item.references, item.name)],
-      ");"
-    ];
-  }
-  if (kind === "check" && item.check) {
-    return [`await db.addCheck(${table}, ${item.check.toCode("t")});`];
-  }
-  return [
-    `await db.addConstraint(${table}, {`,
-    pqb.constraintPropsToCode("t", item),
-    "});"
-  ];
-};
-const createView = (ast) => {
-  const code = [`await db.createView(${quoteSchemaTable(ast)}`];
-  const options = [];
-  if (ast.options.recursive)
-    options.push("recursive: true,");
-  const w = ast.options.with;
-  if (w == null ? void 0 : w.checkOption)
-    options.push(`checkOption: '${w.checkOption}',`);
-  if (w == null ? void 0 : w.securityBarrier)
-    options.push(`securityBarrier: ${w.securityBarrier},`);
-  if (w == null ? void 0 : w.securityInvoker)
-    options.push(`securityInvoker: ${w.securityInvoker},`);
-  if (options.length) {
-    orchidCore.addCode(code, ", {");
-    code.push(options, "}");
-  }
-  orchidCore.addCode(code, ", ");
-  if (!ast.sql._values) {
-    const raw = ast.sql._sql;
-    let sql;
-    if (typeof raw === "string") {
-      sql = raw;
-    } else {
-      sql = "";
-      const parts = raw[0];
-      const last = parts.length - 1;
-      for (let i = 0; i < last; i++) {
-        sql += parts[i] + `\${${raw[i + 1]}}`;
-      }
-      sql += parts[last];
-    }
-    orchidCore.addCode(code, orchidCore.backtickQuote(sql));
-  } else {
-    orchidCore.addCode(code, ast.sql.toCode("db"));
-  }
-  orchidCore.addCode(code, ");");
-  return code;
+const timestampsToCode = (config, { hasTZTimestamps, hasAnyCamelCaseTimestamps }) => {
+  const key = hasTZTimestamps ? "timestamps" : "timestampsNoTZ";
+  return `t.${hasAnyCamelCaseTimestamps || config.snakeCase ? key : `${key}SnakeCase`}()`;
 };
 
 const pullDbStructure = async (options, config) => {
-  var _a, _b, _c, _d;
+  var _a, _b;
   const adapter = new pqb.Adapter(options);
   const currentSchema = adapter.schema || "public";
-  const ctx = {
-    snakeCase: config.snakeCase,
-    unsupportedTypes: {},
-    currentSchema,
-    columnSchemaConfig: config.schemaConfig,
-    columnsByType: pqb.makeColumnsByType(config.schemaConfig)
-  };
+  const ctx = makeStructureToAstCtx(config, currentSchema);
   const ast = await structureToAst(ctx, adapter);
   await adapter.close();
-  const result = astToMigration(config, ast);
+  const result = astToMigration(currentSchema, config, ast);
   if (!result)
     return;
   const version = await makeFileVersion({}, config);
@@ -4361,33 +5214,11 @@ const pullDbStructure = async (options, config) => {
     silentArrays: adapter.arrays
   });
   await saveMigratedVersion(silentQueries, version, "pull", config);
-  const cache = {};
-  for (const item of ast) {
-    await ((_a = config == null ? void 0 : config.appCodeUpdater) == null ? void 0 : _a.process({
-      ast: item,
-      options,
-      basePath: config.basePath,
-      cache,
-      logger: config.logger,
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      baseTable: config.baseTable,
-      import: config.import
-    }));
-  }
-  await ((_b = config == null ? void 0 : config.appCodeUpdater) == null ? void 0 : _b.afterAll({
-    options,
-    basePath: config.basePath,
-    cache,
-    logger: config.logger,
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    baseTable: config.baseTable,
-    import: config.import
-  }));
   const unsupportedEntries = Object.entries(ctx.unsupportedTypes);
   const len = unsupportedEntries.length;
   if (len) {
     let count = 0;
-    (_c = config.logger) == null ? void 0 : _c.warn(
+    (_a = config.logger) == null ? void 0 : _a.warn(
       `Found unsupported types:
 ${unsupportedEntries.map(([type, columns]) => {
         count += columns.length;
@@ -4396,7 +5227,7 @@ ${unsupportedEntries.map(([type, columns]) => {
 Append \`as\` method manually to ${count > 1 ? "these" : "this"} column${count > 1 ? "s" : ""} to treat ${count > 1 ? "them" : "it"} as other column type`
     );
   }
-  (_d = config.logger) == null ? void 0 : _d.log("Database pulled successfully");
+  (_b = config.logger) == null ? void 0 : _b.log("Database pulled successfully");
   adapter.close();
 };
 
@@ -4445,7 +5276,7 @@ const readdirRecursive = async (dirPath, cb) => {
 };
 
 const listMigrationsStatuses = async (options, config, args) => {
-  var _a, _b;
+  var _a;
   const adapters = options.map((opts) => new pqb.Adapter(opts));
   const ctx = {};
   const [{ migrations }, ...migrated] = await Promise.all([
@@ -4486,23 +5317,25 @@ const listMigrationsStatuses = async (options, config, args) => {
     };
   }
   const showUrl = args.includes("p") || args.includes("path");
-  const colors = typeof config.log === "object" ? (_a = config.log.colors) != null ? _a : true : true;
-  const yellow = colors ? (s) => `\x1B[33m${s}\x1B[0m` : (s) => s;
-  const green = colors ? (s) => `\x1B[32m${s}\x1B[0m` : (s) => s;
-  const red = colors ? (s) => `\x1B[31m${s}\x1B[0m` : (s) => s;
-  const blue = colors ? (s) => `\x1B[34m${s}\x1B[0m` : (s) => s;
+  const asIs = (s) => s;
+  const c = typeof config.log === "object" && config.log.colors === false ? {
+    yellow: asIs,
+    green: asIs,
+    red: asIs,
+    blue: asIs
+  } : colors;
   const log = Object.values(map).map(({ databases, migrations: migrations2 }) => {
-    let log2 = ` ${yellow("Database:")} ${databases.join(", ")}`;
+    let log2 = ` ${c.yellow("Database:")} ${databases.join(", ")}`;
     if (migrations2.length === 0) {
       return log2 + `
 
 No migrations available`;
     }
-    const lineSeparator = yellow(
+    const lineSeparator = c.yellow(
       makeChars(14 + maxVersionLength + maxNameLength, "-")
     );
-    const columnSeparator = yellow("|");
-    log2 += "\n\n " + yellow(
+    const columnSeparator = c.yellow("|");
+    log2 += "\n\n " + c.yellow(
       `Status | Migration ID${makeChars(
         maxVersionLength - 12,
         " "
@@ -4511,7 +5344,7 @@ ${lineSeparator}`
     );
     for (const migration of migrations2) {
       log2 += `
-  ${migration.up ? ` ${green("Up")} ` : red("Down")}  ${columnSeparator} ${blue(migration.version)}${makeChars(
+  ${migration.up ? ` ${c.green("Up")} ` : c.red("Down")}  ${columnSeparator} ${c.blue(migration.version)}${makeChars(
         maxVersionLength - migration.version.length,
         " "
       )} ${columnSeparator} ${migration.name}`;
@@ -4524,7 +5357,7 @@ ${migration.url}
     return log2 += showUrl ? lineSeparator : `
 ${lineSeparator}`;
   }).join("\n\n");
-  ((_b = config.logger) != null ? _b : console).log(log);
+  ((_a = config.logger) != null ? _a : console).log(log);
   await Promise.all(adapters.map((adapter) => adapter.close()));
 };
 const makeChars = (count, char) => {
@@ -4612,24 +5445,12 @@ const rebase = async (options, config) => {
         migratedFiles.push(moveFile);
       } else if (!moveFile) {
         move++;
-        const result = await prompts([
-          {
-            type: "select",
-            name: "file",
-            message: "Which should go first?",
-            choices: [
-              {
-                title: prev.name,
-                value: "prev"
-              },
-              {
-                title: file.name,
-                value: "current"
-              }
-            ]
-          }
-        ]);
-        moveFile = result.file === "prev" ? prev : file;
+        const result = await promptSelect({
+          message: "Which should go first?",
+          options: [prev.name, file.name],
+          active: (s) => `${colors.yellow("\u276F")} ${colors.yellow(s)}`
+        });
+        moveFile = result ? file : prev;
       }
     }
     let newVersion = file.serial;
@@ -4702,7 +5523,7 @@ const rebase = async (options, config) => {
     return files2;
   }, []).sort((a, b) => +b.version - +a.version);
   set.migrations = migrationsDown;
-  await rakeDb$1.redo(
+  await redo(
     ctx,
     options,
     __spreadProps(__spreadValues$1({}, config), {
@@ -4782,42 +5603,72 @@ const rakeDbAliases = {
   rec: "recurrent"
 };
 const runCommand = async (opts, config, args = process.argv.slice(2)) => {
-  var _a, _b;
+  var _a, _b, _c;
   let arg = (_a = args[0]) == null ? void 0 : _a.split(":")[0];
   if (rakeDbAliases[arg]) {
     args = [...args];
     arg = args[0] = rakeDbAliases[arg];
   }
   const options = orchidCore.toArray(opts);
-  if (arg === "create") {
-    await createDb(options, config);
-  } else if (arg === "drop") {
-    await dropDb(options, config);
-  } else if (arg === "reset") {
-    await resetDb(options, config);
-  } else if (arg === "up") {
-    await migrate({}, options, config, args.slice(1));
-  } else if (arg === "down") {
-    await rollback({}, options, config, args.slice(1));
-  } else if (arg === "redo") {
-    await redo({}, options, config, args.slice(1));
-  } else if (arg === "new") {
-    await generate(config, args.slice(1));
-  } else if (arg === "pull") {
-    await pullDbStructure(options[0], config);
-  } else if (arg === "status") {
-    await listMigrationsStatuses(options, config, args.slice(1));
-  } else if (arg === "rebase") {
-    await rebase(options, config);
-  } else if (arg === "change-ids") {
-    await changeIds(options, config, args.slice(1));
-  } else if (config.commands[arg]) {
-    await config.commands[arg](options, config, args.slice(1));
-  } else if (arg !== "recurrent") {
-    (_b = config.logger) == null ? void 0 : _b.log(help);
-  }
-  if (arg === "up" || arg === "recurrent" || arg === "redo") {
-    await runRecurrentMigrations(options, config);
+  args.shift();
+  const command = (_c = (_b = rakeDbCommands[arg]) == null ? void 0 : _b.run) != null ? _c : config.commands[arg];
+  if (command) {
+    await command(options, config, args);
+  } else if (config.logger) {
+    const commandsHelp = [];
+    let max = 0;
+    let maxArgs = 0;
+    const addedCommands = /* @__PURE__ */ new Map();
+    for (let key in rakeDbCommands) {
+      const command2 = rakeDbCommands[key];
+      const added = addedCommands.get(command2);
+      if (added)
+        key = added[0] += `, ${key}`;
+      if (key.length > max)
+        max = key.length;
+      if (added)
+        continue;
+      if (command2.helpArguments) {
+        maxArgs = Math.max(
+          maxArgs,
+          ...Object.keys(command2.helpArguments).map((key2) => key2.length + 5)
+        );
+      }
+      const helpBlock = [key, command2.help, command2.helpArguments];
+      addedCommands.set(command2, helpBlock);
+      if (command2.helpAfter) {
+        const i = commandsHelp.findIndex(([key2]) => key2 === command2.helpAfter);
+        if (i === -1) {
+          throw new Error(
+            `${command2.helpAfter} command is required for ${key} but is not found`
+          );
+        }
+        commandsHelp.splice(i + 1, 0, helpBlock);
+      } else {
+        commandsHelp.push(helpBlock);
+      }
+    }
+    config.logger.log(`Usage: rake-db [command] [arguments]
+
+See documentation at:
+https://orchid-orm.netlify.app/guide/migration-commands.html
+
+Commands:
+
+${commandsHelp.map(([key, help, helpArguments]) => {
+      let result = `${key}  ${help.padStart(max - key.length + help.length)}`;
+      if (helpArguments) {
+        result += `
+  arguments:
+${Object.entries(helpArguments).map(
+          ([arg2, help2]) => `    ${arg2} ${`  ${help2}`.padStart(
+            maxArgs - arg2.length - 5 + help2.length + 2
+          )}`
+        ).join("\n")}`;
+      }
+      return result;
+    }).join("\n\n")}
+`);
   }
   return {
     options,
@@ -4825,70 +5676,164 @@ const runCommand = async (opts, config, args = process.argv.slice(2)) => {
     args
   };
 };
-const help = `Usage: rake-db [command] [arguments]
-
-See documentation at:
-https://orchid-orm.netlify.app/guide/migration-commands.html
-
-Commands:
-  create                  create databases
-  drop                    drop databases
-  reset                   drop, create and migrate databases
-  pull                    generate a combined migration for an existing database
-  new                     create new migration file, see below
-  up                      migrate pending migrations
-  migrate                 migrate pending migrations, also run recurrent
-  up|migrate force        resolve the case of a non-migrated file in the middle
-  rollback or down        rollback the last migrated
-  redo                    rollback and migrate, run recurrent
-  status or s             list migrations statuses
-  status path or s p      list migrations statuses and paths to files
-  rec or recurrent        run recurrent migrations
-  rebase                  move local migrations below the new ones from upstream
-  change-ids serial       change migrations ids to 4 digit serial
-  change-ids serial 42    change migrations ids to custom digits serial
-  change-ids timestamp    change migrations ids to timestamps
-  no or unknown command   prints this message
-  
-Migrate arguments:
-  no arguments            run all pending migrations
-  number                  run specific number of pending migrations
-
-Rollback arguments:
-  no arguments            rollback one last applied migration
-  number                  rollback specific number of applied migrations
-  all                     rollback all applied migrations
-
-Migrate and rollback common arguments:
-  --code                  run code updater, overrides \`useCodeUpdater\` option
-  --code false            do not run code updater
-`;
+const upCommand = {
+  run: (options, config, args) => migrate({}, options, config, args).then(
+    () => runRecurrentMigrations(options, config)
+  ),
+  help: "migrate pending migrations",
+  helpArguments: {
+    "no arguments": "migrate all pending",
+    "a number": "run a specific number of pending migrations",
+    force: "enforce migrating a pending file in the middle"
+  }
+};
+const downCommand = {
+  run: (options, config, args) => rollback({}, options, config, args),
+  help: "rollback migrated migrations",
+  helpArguments: {
+    "no arguments": "rollback one last migration",
+    "a number": "rollback a specified number",
+    all: "rollback all migrations"
+  }
+};
+const statusCommand = {
+  run: listMigrationsStatuses,
+  help: "list migrations statuses",
+  helpArguments: {
+    "no arguments": `does not print file paths`,
+    "p, path": "also print file paths"
+  }
+};
+const recurrentCommand = {
+  run: runRecurrentMigrations,
+  help: "run recurrent migrations"
+};
+const rakeDbCommands = {
+  create: {
+    run: createDb,
+    help: "create databases"
+  },
+  drop: {
+    run: dropDb,
+    help: "drop databases"
+  },
+  reset: {
+    run: resetDb,
+    help: "drop, create and migrate databases"
+  },
+  up: upCommand,
+  migrate: upCommand,
+  down: downCommand,
+  rollback: downCommand,
+  redo: {
+    run: (options, config, args) => redo({}, options, config, args).then(
+      () => runRecurrentMigrations(options, config)
+    ),
+    help: "rollback and migrate, run recurrent"
+  },
+  pull: {
+    run: ([options], config) => pullDbStructure(options, config),
+    help: "generate a combined migration for an existing database"
+  },
+  new: {
+    run: (_, config, args) => newMigration(config, args),
+    help: "create new migration file"
+  },
+  s: statusCommand,
+  status: statusCommand,
+  rec: recurrentCommand,
+  recurrent: recurrentCommand,
+  rebase: {
+    run: rebase,
+    help: "move local migrations below the new ones from upstream"
+  },
+  "change-ids": {
+    run: changeIds,
+    help: "change migrations ids format",
+    helpArguments: {
+      serial: "change ids to 4 digit serial",
+      "serial *number*": "change ids to serial number of custom length",
+      "change-ids timestamp": "change ids to timestamps"
+    }
+  }
+};
 
 exports.Migration = Migration;
 exports.NoMigrationsTableError = NoMigrationsTableError;
 exports.RAKE_DB_LOCK_KEY = RAKE_DB_LOCK_KEY;
+exports.addColumnComment = addColumnComment;
+exports.addColumnIndex = addColumnIndex;
 exports.addOrDropEnumValues = addOrDropEnumValues;
+exports.astToMigration = astToMigration;
 exports.changeCache = changeCache;
 exports.changeEnumValues = changeEnumValues;
+exports.clearChanges = clearChanges;
+exports.colors = colors;
+exports.columnToSql = columnToSql;
+exports.columnTypeToSql = columnTypeToSql;
+exports.commentsToQuery = commentsToQuery;
+exports.concatSchemaAndName = concatSchemaAndName;
+exports.constraintToSql = constraintToSql;
 exports.createDb = createDb;
 exports.createMigrationInterface = createMigrationInterface;
+exports.dbColumnToAst = dbColumnToAst;
 exports.deleteMigratedVersion = deleteMigratedVersion;
 exports.dropDb = dropDb;
-exports.generate = generate;
+exports.encodeColumnDefault = encodeColumnDefault;
+exports.exhaustive = exhaustive;
 exports.generateTimeStamp = generateTimeStamp;
+exports.getColumnName = getColumnName;
+exports.getConstraintName = getConstraintName;
+exports.getCurrentChanges = getCurrentChanges;
 exports.getDatabaseAndUserFromOptions = getDatabaseAndUserFromOptions;
+exports.getDbStructureTableData = getDbStructureTableData;
+exports.getDbTableColumnsChecks = getDbTableColumnsChecks;
+exports.getFirstWordAndRest = getFirstWordAndRest;
+exports.getForeignKeyTable = getForeignKeyTable;
+exports.getIndexName = getIndexName;
 exports.getMigratedVersionsMap = getMigratedVersionsMap;
+exports.getSchemaAndTableFromName = getSchemaAndTableFromName;
+exports.getTextAfterFrom = getTextAfterFrom;
+exports.getTextAfterTo = getTextAfterTo;
+exports.identityToSql = identityToSql;
+exports.indexesToQuery = indexesToQuery;
+exports.instantiateDbColumn = instantiateDbColumn;
+exports.introspectDbSchema = introspectDbSchema;
+exports.joinColumns = joinColumns;
+exports.joinWords = joinWords;
+exports.makeDbStructureColumnsShape = makeDbStructureColumnsShape;
+exports.makeDomainsMap = makeDomainsMap;
 exports.makeFileVersion = makeFileVersion;
+exports.makePopulateEnumQuery = makePopulateEnumQuery;
+exports.makeStructureToAstCtx = makeStructureToAstCtx;
 exports.migrate = migrate;
 exports.migrateOrRollback = migrateOrRollback;
 exports.migrationConfigDefaults = migrationConfigDefaults;
+exports.newMigration = newMigration;
+exports.pluralize = pluralize;
+exports.primaryKeyToSql = primaryKeyToSql;
 exports.processRakeDbConfig = processRakeDbConfig;
+exports.promptConfirm = promptConfirm;
+exports.promptSelect = promptSelect;
+exports.promptText = promptText;
+exports.pushChange = pushChange;
+exports.queryLock = queryLock;
+exports.quoteNameFromString = quoteNameFromString;
+exports.quoteSchemaTable = quoteSchemaTable;
+exports.quoteTable = quoteTable;
+exports.quoteWithSchema = quoteWithSchema;
 exports.rakeDb = rakeDb;
 exports.rakeDbAliases = rakeDbAliases;
+exports.rakeDbCommands = rakeDbCommands;
 exports.redo = redo;
+exports.referencesToSql = referencesToSql;
 exports.renameType = renameType;
 exports.resetDb = resetDb;
 exports.rollback = rollback;
 exports.saveMigratedVersion = saveMigratedVersion;
+exports.structureToAst = structureToAst;
+exports.tableToAst = tableToAst;
+exports.transaction = transaction;
+exports.versionToString = versionToString;
 exports.writeMigrationFile = writeMigrationFile;
 //# sourceMappingURL=index.js.map