orchid-orm 1.31.7 → 1.32.1

package/dist/migrations.mjs

@@ -1,7 +1,7 @@
 import { promptSelect, colors, getSchemaAndTableFromName, getDbTableColumnsChecks, dbColumnToAst, instantiateDbColumn, concatSchemaAndName, encodeColumnDefault, getIndexName, getConstraintName, tableToAst, getDbStructureTableData, makeDomainsMap, astToMigration, createMigrationInterface, introspectDbSchema, exhaustive, pluralize, makeStructureToAstCtx, makeFileVersion, writeMigrationFile, migrate, structureToAst, saveMigratedVersion, rakeDbCommands } from 'rake-db';
 export * from 'rake-db';
+import { toSnakeCase, deepCompare, toArray, columnToCode, addCode, codeToString, toCamelCase, toPascalCase, getImportPath, singleQuote, quoteObjectKey, pathToLog } from 'orchid-core';
 import { EnumColumn, DomainColumn, RawSQL, ArrayColumn, VirtualColumn, UnknownColumn, defaultSchemaConfig, columnsShapeToCode, pushTableDataCode, Adapter } from 'pqb';
-import { deepCompare, toArray, addCode, codeToString, toCamelCase, toPascalCase, getImportPath, singleQuote, quoteObjectKey, pathToLog } from 'orchid-core';
 import path from 'node:path';
 import { pathToFileURL } from 'url';
 import fs from 'fs/promises';
@@ -100,7 +100,16 @@ const promptCreateOrRename = (kind, name, drop, verifying) => {
 };
 const checkForColumnChange = (shape, key) => {
   const item = shape[key];
-  return item && (Array.isArray(item) || item.type !== "rename");
+  if (item) {
+    return item && (Array.isArray(item) || item.type !== "rename");
+  }
+  for (const k in shape) {
+    const item2 = shape[k];
+    if (Array.isArray(item2) || item2.type !== "rename") {
+      return true;
+    }
+  }
+  return false;
 };
 
 const processSchemas = async (ast, schemas, dbStructure, verifying) => {
@@ -172,19 +181,19 @@ const renameSchemaInStructures = (items, from, to) => {
   }
 };
 
-var __defProp$6 = Object.defineProperty;
-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 __defProp$7 = Object.defineProperty;
+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$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$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;
 };
@@ -218,7 +227,7 @@ const processExtensions = (ast, dbStructure, currentSchema, extensions) => {
   }
   if (codeExtensions == null ? void 0 : codeExtensions.length) {
     ast.push(
-      ...codeExtensions.map((ext) => __spreadValues$6({
+      ...codeExtensions.map((ext) => __spreadValues$7({
         type: "extension",
         action: "create"
       }, ext))
@@ -226,23 +235,23 @@ const processExtensions = (ast, dbStructure, currentSchema, extensions) => {
   }
 };
 
-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) => {
+var __defProp$6 = Object.defineProperty;
+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$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]);
+    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;
 };
-const processColumns = async (adapter, structureToAstCtx, dbStructure, domainsMap, changeTableData, ast, currentSchema, compareSql, typeCastsCache, verifying) => {
+const processColumns = async (adapter, config, structureToAstCtx, dbStructure, domainsMap, changeTableData, ast, currentSchema, compareSql, typeCastsCache, verifying) => {
   const { dbTable } = changeTableData;
   const dbColumns = Object.fromEntries(
     dbTable.columns.map((column) => [column.name, column])
@@ -255,6 +264,7 @@ const processColumns = async (adapter, structureToAstCtx, dbStructure, domainsMa
     changeTableData
   );
   await addOrRenameColumns(
+    config,
     dbStructure,
     changeTableData,
     columnsToAdd,
@@ -264,6 +274,7 @@ const processColumns = async (adapter, structureToAstCtx, dbStructure, domainsMa
   );
   await changeColumns(
     adapter,
+    config,
     structureToAstCtx,
     dbStructure,
     domainsMap,
@@ -283,6 +294,7 @@ const groupColumns = (structureToAstCtx, dbStructure, domainsMap, dbColumns, cha
   const columnsToAdd = [];
   const columnsToDrop = [];
   const columnsToChange = /* @__PURE__ */ new Map();
+  const columnsToChangeByDbName = /* @__PURE__ */ new Map();
   const { codeTable, dbTable, dbTableData } = changeTableData;
   const checks = getDbTableColumnsChecks(changeTableData.dbTableData);
   for (const key in codeTable.shape) {
@@ -291,13 +303,14 @@ const groupColumns = (structureToAstCtx, dbStructure, domainsMap, dbColumns, cha
       continue;
     const name = (_a = column.data.name) != null ? _a : key;
     if (dbColumns[name]) {
-      columnsToChange.set(name, column);
+      columnsToChange.set(key, { key, dbName: name, column });
+      columnsToChangeByDbName.set(name, true);
     } else {
-      columnsToAdd.push({ key: name, column });
+      columnsToAdd.push({ key, column });
     }
   }
   for (const name in dbColumns) {
-    if (columnsToChange.has(name))
+    if (columnsToChangeByDbName.has(name))
       continue;
     const [key, column] = dbColumnToAst(
       structureToAstCtx,
@@ -317,46 +330,52 @@ const groupColumns = (structureToAstCtx, dbStructure, domainsMap, dbColumns, cha
     columnsToChange
   };
 };
-const addOrRenameColumns = async (dbStructure, {
+const addOrRenameColumns = async (config, dbStructure, {
   dbTableData,
   schema,
   changeTableAst: { name: tableName, shape }
 }, columnsToAdd, columnsToDrop, columnsToChange, verifying) => {
-  var _a, _b;
+  var _a, _b, _c, _d, _e;
   for (const { key, column } of columnsToAdd) {
     if (columnsToDrop.length) {
+      const codeName = (_a = column.data.name) != null ? _a : key;
       const index = await promptCreateOrRename(
         "column",
-        (_a = column.data.name) != null ? _a : key,
+        codeName,
         columnsToDrop.map((x) => x.key),
         verifying
       );
       if (index) {
         const drop = columnsToDrop[index - 1];
         columnsToDrop.splice(index - 1, 1);
-        const from = drop.key;
-        columnsToChange.set(from, column.name(key));
+        const from = (_b = drop.column.data.name) != null ? _b : drop.key;
+        columnsToChange.set((_c = drop.column.data.name) != null ? _c : from, {
+          key,
+          dbName: (_d = drop.column.data.name) != null ? _d : from,
+          column: column.name(codeName)
+        });
+        const to = config.snakeCase ? toSnakeCase(key) : key;
         if (dbTableData.primaryKey) {
-          renameColumn(dbTableData.primaryKey.columns, from, key);
+          renameColumn(dbTableData.primaryKey.columns, from, to);
         }
         for (const index2 of dbTableData.indexes) {
           for (const column2 of index2.columns) {
             if ("column" in column2 && column2.column === from) {
-              column2.column = key;
+              column2.column = to;
             }
           }
         }
         for (const c of dbTableData.constraints) {
-          if ((_b = c.check) == null ? void 0 : _b.columns) {
-            renameColumn(c.check.columns, from, key);
+          if ((_e = c.check) == null ? void 0 : _e.columns) {
+            renameColumn(c.check.columns, from, to);
           }
           if (c.references) {
-            renameColumn(c.references.columns, from, key);
+            renameColumn(c.references.columns, from, to);
           }
         }
         for (const c of dbStructure.constraints) {
           if (c.references && c.references.foreignSchema === schema && c.references.foreignTable === tableName) {
-            renameColumn(c.references.foreignColumns, from, key);
+            renameColumn(c.references.foreignColumns, from, to);
           }
         }
         continue;
@@ -376,11 +395,14 @@ const dropColumns = ({ changeTableAst: { shape } }, columnsToDrop) => {
     };
   }
 };
-const changeColumns = async (adapter, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, dbColumns, columnsToChange, compareSql, changeTableData, typeCastsCache, verifying) => {
-  var _a, _b, _c, _d, _e, _f;
-  const { shape } = changeTableData.changeTableAst;
-  for (const [name, codeColumn] of columnsToChange) {
-    const dbColumnStructure = dbColumns[name];
+const changeColumns = async (adapter, config, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, dbColumns, columnsToChange, compareSql, changeTableData, typeCastsCache, verifying) => {
+  var _a, _b, _c, _d, _e;
+  for (const [
+    key,
+    { key: codeKey, dbName, column: codeColumn }
+  ] of columnsToChange) {
+    const dbColumnStructure = dbColumns[dbName];
+    const { shape } = changeTableData.changeTableAst;
     let changed = false;
     const dbColumn = instantiateDbColumn(
       structureToAstCtx,
@@ -429,7 +451,7 @@ JOIN pg_type AS t ON t.oid = casttarget`);
             throw new AbortSignal();
           const tableName = concatSchemaAndName(changeTableData.changeTableAst);
           const abort = await promptSelect({
-            message: `Cannot cast type of ${tableName}'s column ${name} from ${dbType} to ${codeType}`,
+            message: `Cannot cast type of ${tableName}'s column ${key} from ${dbType} to ${codeType}`,
             options: [
               `${colors.yellowBold(
                 `-/+`
@@ -442,7 +464,8 @@ JOIN pg_type AS t ON t.oid = casttarget`);
           if (abort) {
             throw new AbortSignal();
           }
-          shape[name] = [
+          dbColumn.data.name = codeColumn.data.name;
+          shape[key] = [
             {
               type: "drop",
               item: dbColumn
@@ -452,7 +475,7 @@ JOIN pg_type AS t ON t.oid = casttarget`);
               item: codeColumn
             }
           ];
-          continue;
+          return;
         }
       }
       changed = true;
@@ -462,15 +485,15 @@ JOIN pg_type AS t ON t.oid = casttarget`);
     if (!changed) {
       if (!dbData.isNullable)
         dbData.isNullable = void 0;
-      for (const key of ["isNullable", "comment"]) {
-        if (dbData[key] !== codeData[key]) {
+      for (const key2 of ["isNullable", "comment"]) {
+        if (dbData[key2] !== codeData[key2]) {
           changed = true;
           break;
         }
       }
     }
     if (!changed) {
-      for (const key of [
+      for (const key2 of [
         "maxChars",
         "collation",
         "compression",
@@ -478,7 +501,7 @@ JOIN pg_type AS t ON t.oid = casttarget`);
         "numericScale",
         "dateTimePrecision"
       ]) {
-        if (key in codeData && dbData[key] !== codeData[key]) {
+        if (key2 in codeData && dbData[key2] !== codeData[key2]) {
           changed = true;
           break;
         }
@@ -486,7 +509,7 @@ JOIN pg_type AS t ON t.oid = casttarget`);
     }
     if (!changed && !deepCompare(
       dbData.identity,
-      codeData.identity ? __spreadValues$5({
+      codeData.identity ? __spreadValues$6({
         always: false,
         start: 1,
         increment: 1,
@@ -518,7 +541,7 @@ JOIN pg_type AS t ON t.oid = casttarget`);
           inDb: dbDefault,
           inCode: codeDefault,
           change: () => {
-            changeColumn(shape, name, dbColumn, codeColumn);
+            changeColumn(shape, key, dbColumn, codeColumn);
             if (!changeTableData.pushedAst) {
               changeTableData.pushedAst = true;
               ast.push(changeTableData.changeTableAst);
@@ -528,14 +551,13 @@ JOIN pg_type AS t ON t.oid = casttarget`);
       }
     }
     if (changed) {
-      changeColumn(shape, name, dbColumn, codeColumn);
+      changeColumn(shape, key, dbColumn, codeColumn);
     } else {
-      const from = (_e = dbColumn.data.name) != null ? _e : name;
-      const to = (_f = codeColumn.data.name) != null ? _f : name;
-      if (from !== to) {
-        shape[from] = {
+      const to = (_e = codeColumn.data.name) != null ? _e : codeKey;
+      if (dbName !== to) {
+        shape[config.snakeCase ? dbName === toSnakeCase(codeKey) ? codeKey : dbName : dbName] = {
           type: "rename",
-          name: to
+          name: config.snakeCase ? to === toSnakeCase(codeKey) ? codeKey : to : to
         };
       }
     }
@@ -730,19 +752,19 @@ const createAst = (codeDomain) => ({
   baseType: codeDomain.column
 });
 
-var __defProp$4 = Object.defineProperty;
-var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
-var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
-var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$4 = (a, b) => {
+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$4.call(b, prop))
-      __defNormalProp$4(a, prop, b[prop]);
-  if (__getOwnPropSymbols$4)
-    for (var prop of __getOwnPropSymbols$4(b)) {
-      if (__propIsEnum$4.call(b, prop))
-        __defNormalProp$4(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;
 };
@@ -822,7 +844,7 @@ const processEnums = async (ast, enums, dbStructure, currentSchema, verifying) =
         continue;
       }
     }
-    ast.push(__spreadValues$4({
+    ast.push(__spreadValues$5({
       type: "enum",
       action: "create"
     }, codeEnum));
@@ -883,20 +905,20 @@ const renameColumnsTypeSchema = (dbStructure, from, to) => {
   }
 };
 
-const processPrimaryKey = (ast, changeTableData) => {
+const processPrimaryKey = (config, ast, changeTableData) => {
   var _a;
   const { codeTable } = changeTableData;
   const columnsPrimaryKey = [];
   for (const key in codeTable.shape) {
     const column = codeTable.shape[key];
     if (column.data.primaryKey) {
-      columnsPrimaryKey.push((_a = column.data.name) != null ? _a : key);
+      columnsPrimaryKey.push({ key, name: (_a = column.data.name) != null ? _a : key });
     }
   }
-  changePrimaryKey(columnsPrimaryKey, changeTableData);
+  changePrimaryKey(config, columnsPrimaryKey, changeTableData);
   renamePrimaryKey(ast, changeTableData);
 };
-const changePrimaryKey = (columnsPrimaryKey, {
+const changePrimaryKey = (config, columnsPrimaryKey, {
   codeTable,
   dbTableData: { primaryKey: dbPrimaryKey },
   changeTableAst: { shape, add, drop }
@@ -904,19 +926,29 @@ const changePrimaryKey = (columnsPrimaryKey, {
   var _a;
   const tablePrimaryKey = codeTable.internal.tableData.primaryKey;
   const primaryKey = [
-    .../* @__PURE__ */ new Set([...columnsPrimaryKey, ...(_a = tablePrimaryKey == null ? void 0 : tablePrimaryKey.columns) != null ? _a : []])
+    .../* @__PURE__ */ new Set([
+      ...columnsPrimaryKey,
+      ...(_a = config.snakeCase ? tablePrimaryKey == null ? void 0 : tablePrimaryKey.columns.map((key) => ({
+        key,
+        name: toSnakeCase(key)
+      })) : tablePrimaryKey == null ? void 0 : tablePrimaryKey.columns.map((key) => ({ key, name: key }))) != null ? _a : []
+    ])
   ];
-  if (!dbPrimaryKey || primaryKey.length !== dbPrimaryKey.columns.length || primaryKey.some((a) => !dbPrimaryKey.columns.some((b) => a === b))) {
+  if (!dbPrimaryKey || primaryKey.length !== dbPrimaryKey.columns.length || primaryKey.some(
+    ({ name }) => !dbPrimaryKey.columns.some((dbName) => name === dbName)
+  )) {
     const toDrop = dbPrimaryKey == null ? void 0 : dbPrimaryKey.columns.filter(
       (key) => !checkForColumnChange(shape, key)
     );
     if (toDrop == null ? void 0 : toDrop.length) {
       drop.primaryKey = { columns: toDrop, name: dbPrimaryKey == null ? void 0 : dbPrimaryKey.name };
     }
-    const toAdd = primaryKey.filter((key) => !checkForColumnChange(shape, key));
+    const toAdd = primaryKey.filter(
+      ({ key }) => !checkForColumnChange(shape, key)
+    );
     if (toAdd.length) {
       add.primaryKey = {
-        columns: toAdd,
+        columns: toAdd.map((c) => c.key),
         name: tablePrimaryKey == null ? void 0 : tablePrimaryKey.name
       };
     }
@@ -941,40 +973,43 @@ const renamePrimaryKey = (ast, {
   }
 };
 
-var __defProp$3 = Object.defineProperty;
-var __defProps$3 = Object.defineProperties;
-var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
-var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
-var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$3 = (a, b) => {
+var __defProp$4 = Object.defineProperty;
+var __defProps$4 = Object.defineProperties;
+var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$3.call(b, prop))
-      __defNormalProp$3(a, prop, b[prop]);
-  if (__getOwnPropSymbols$3)
-    for (var prop of __getOwnPropSymbols$3(b)) {
-      if (__propIsEnum$3.call(b, prop))
-        __defNormalProp$3(a, prop, b[prop]);
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
-    if (__hasOwnProp$3.call(source, prop) && exclude.indexOf(prop) < 0)
+    if (__hasOwnProp$4.call(source, prop) && exclude.indexOf(prop) < 0)
       target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols$3)
-    for (var prop of __getOwnPropSymbols$3(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum$3.call(source, prop))
+  if (source != null && __getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$4.call(source, prop))
         target[prop] = source[prop];
     }
   return target;
 };
 const processIndexes = (config, changeTableData, delayedAst, ast, compareExpressions) => {
-  const codeIndexes = collectCodeIndexes(changeTableData);
-  const codeComparableIndexes = collectCodeComparableIndexes(codeIndexes);
+  const codeIndexes = collectCodeIndexes(config, changeTableData);
+  const codeComparableIndexes = collectCodeComparableIndexes(
+    config,
+    codeIndexes
+  );
   const skipCodeIndexes = /* @__PURE__ */ new Map();
   const holdCodeIndexes = /* @__PURE__ */ new Map();
   let wait = 0;
@@ -1069,13 +1104,13 @@ const processIndexes = (config, changeTableData, delayedAst, ast, compareExpress
     (index, i) => !skipCodeIndexes.has(i) && !holdCodeIndexes.has(index)
   );
   if (addIndexes.length) {
-    changeTableData.changeTableAst.add.indexes = addIndexes;
+    changeTableData.changeTableAst.add.indexes = addIndexes.map((x) => __spreadProps$4(__spreadValues$4({}, x), {
+      columns: x.columnKeys,
+      options: x.options.include ? __spreadProps$4(__spreadValues$4({}, x.options), { include: x.includeKeys }) : x.options
+    }));
   }
 };
-const collectCodeIndexes = ({
-  codeTable,
-  changeTableAst: { shape }
-}) => {
+const collectCodeIndexes = (config, { codeTable, changeTableAst: { shape } }) => {
   var _a;
   const codeIndexes = [];
   for (const key in codeTable.shape) {
@@ -1093,26 +1128,52 @@ const collectCodeIndexes = ({
           } = _c, _e = _d, { collate, opclass, order, weight } = _e, options = __objRest(_e, ["collate", "opclass", "order", "weight"]), index = __objRest(_c, [
             "options"
           ]);
-          return __spreadValues$3({
-            columns: [{ collate, opclass, order, weight, column: name }],
-            options
-          }, index);
+          return __spreadProps$4(__spreadValues$4({
+            columns: [
+              {
+                collate,
+                opclass,
+                order,
+                weight,
+                column: name
+              }
+            ]
+          }, index), {
+            options: options.include ? config.snakeCase ? __spreadProps$4(__spreadValues$4({}, options), {
+              include: toArray(options.include).map(toSnakeCase)
+            }) : options : options,
+            columnKeys: [{ collate, opclass, order, weight, column: key }],
+            includeKeys: options.include
+          });
         }
       )
     );
   }
   if (codeTable.internal.tableData.indexes) {
-    codeIndexes.push(...codeTable.internal.tableData.indexes);
+    codeIndexes.push(
+      ...codeTable.internal.tableData.indexes.map((x) => __spreadProps$4(__spreadValues$4({}, x), {
+        columns: config.snakeCase ? x.columns.map(
+          (c) => "column" in c ? __spreadProps$4(__spreadValues$4({}, c), { column: toSnakeCase(c.column) }) : c
+        ) : x.columns,
+        columnKeys: x.columns,
+        options: x.options.include && config.snakeCase ? __spreadProps$4(__spreadValues$4({}, x.options), {
+          include: toArray(x.options.include).map(toSnakeCase)
+        }) : x.options,
+        includeKeys: x.options.include
+      }))
+    );
   }
   return codeIndexes;
 };
-const collectCodeComparableIndexes = (codeIndexes) => {
+const collectCodeComparableIndexes = (config, codeIndexes) => {
   return codeIndexes.map((codeIndex) => {
     normalizeIndex(codeIndex.options);
-    return indexToComparable(__spreadProps$3(__spreadValues$3({}, codeIndex.options), {
-      include: codeIndex.options.include === void 0 ? void 0 : toArray(codeIndex.options.include),
+    return indexToComparable(__spreadProps$4(__spreadValues$4({}, codeIndex.options), {
+      include: codeIndex.options.include === void 0 ? void 0 : config.snakeCase ? toArray(codeIndex.options.include).map(toSnakeCase) : toArray(codeIndex.options.include),
       columns: codeIndex.columns,
-      name: codeIndex.name
+      name: codeIndex.name,
+      columnKeys: codeIndex.columnKeys,
+      includeKeys: codeIndex.includeKeys
     }));
   });
 };
@@ -1127,7 +1188,7 @@ const normalizeIndex = (index) => {
 const indexToComparable = (index) => {
   let hasExpression = false;
   const columns = index.columns.map((column) => {
-    const result = __spreadProps$3(__spreadValues$3({}, column), {
+    const result = __spreadProps$4(__spreadValues$4({}, column), {
       expression: void 0,
       hasExpression: "expression" in column
     });
@@ -1135,7 +1196,7 @@ const indexToComparable = (index) => {
       hasExpression = true;
     return result;
   });
-  return __spreadProps$3(__spreadValues$3({}, index), {
+  return __spreadProps$4(__spreadValues$4({}, index), {
     schemaName: void 0,
     tableName: void 0,
     with: void 0,
@@ -1160,8 +1221,12 @@ const findMatchingIndexWithoutSql = (dbIndex, codeComparableIndexes, codeIndexes
       let b = codeIndex;
       const codeName = (_c = b.name) != null ? _c : getIndexName(tableName, dbColumns);
       if (a.name !== b.name) {
-        a = __spreadProps$3(__spreadValues$3({}, a), { name: void 0 });
-        b = __spreadProps$3(__spreadValues$3({}, b), { name: void 0 });
+        a = __spreadProps$4(__spreadValues$4({}, a), { name: void 0 });
+        b = __spreadProps$4(__spreadValues$4({}, b), {
+          name: void 0,
+          columnKeys: void 0,
+          includeKeys: void 0
+        });
         if (a.language && !b.language) {
           b.language = (_d = config.language) != null ? _d : "english";
         }
@@ -1171,9 +1236,16 @@ const findMatchingIndexWithoutSql = (dbIndex, codeComparableIndexes, codeIndexes
             dbIndexWithoutColumns.name !== codeName ? codeName : void 0
           );
         }
-      } else if (deepCompare(dbIndexWithoutColumns, codeIndex)) {
-        found.push(codeIndexes[i]);
-        rename.push(void 0);
+      } else {
+        const _e = codeIndex, codeIndexWithoutKeys = __objRest(_e, [
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          "columnKeys",
+          "includeKeys"
+        ]);
+        if (deepCompare(dbIndexWithoutColumns, codeIndexWithoutKeys)) {
+          found.push(codeIndexes[i]);
+          rename.push(void 0);
+        }
       }
       if (found.length && !checkIfIndexHasSql(codeIndex)) {
         skipCodeIndexes.set(i, true);
@@ -1203,6 +1275,25 @@ const handleIndexChange = (ast, { changeTableAst, schema, codeTable }, dbIndex,
   }
 };
 
+var __defProp$3 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
 const mapMatchToDb = {
   FULL: "f",
   PARTIAL: "p",
@@ -1223,10 +1314,14 @@ const mapActionToCode = {};
 for (const key in mapActionToDb) {
   mapActionToCode[mapActionToDb[key]] = key;
 }
-const processForeignKeys = (ast, changeTables, currentSchema, tableShapes) => {
+const processForeignKeys = (config, ast, changeTables, currentSchema, tableShapes) => {
   var _a, _b, _c;
   for (const changeTableData of changeTables) {
-    const codeForeignKeys = collectCodeFkeys(changeTableData, currentSchema);
+    const codeForeignKeys = collectCodeFkeys(
+      config,
+      changeTableData,
+      currentSchema
+    );
     const { codeTable, dbTableData, changeTableAst, schema } = changeTableData;
     const { shape, add, drop } = changeTableAst;
     let changed = false;
@@ -1253,7 +1348,11 @@ const processForeignKeys = (ast, changeTables, currentSchema, tableShapes) => {
         if (deepCompare(dbReferences, codeReferences)) {
           found = true;
           codeForeignKeys.splice(i, 1);
-          const codeName = (_a = codeForeignKey.codeConstraint.name) != null ? _a : getConstraintName(codeTable.table, codeForeignKey);
+          const codeName = (_a = codeForeignKey.codeConstraint.name) != null ? _a : getConstraintName(
+            codeTable.table,
+            codeForeignKey,
+            config.snakeCase
+          );
           if (codeName !== dbConstraint.name) {
             rename = codeName;
           }
@@ -1261,7 +1360,7 @@ const processForeignKeys = (ast, changeTables, currentSchema, tableShapes) => {
       }
       if (!found) {
         ((_b = drop.constraints) != null ? _b : drop.constraints = []).push(
-          dbForeignKeyToCodeForeignKey(dbConstraint, dbReferences)
+          dbForeignKeyToCodeForeignKey(config, dbConstraint, dbReferences)
         );
         changed = true;
       } else if (rename) {
@@ -1287,7 +1386,7 @@ const processForeignKeys = (ast, changeTables, currentSchema, tableShapes) => {
     }
   }
 };
-const collectCodeFkeys = ({ codeTable, changeTableAst: { shape } }, currentSchema) => {
+const collectCodeFkeys = (config, { codeTable, changeTableAst: { shape } }, currentSchema) => {
   var _a;
   const codeForeignKeys = [];
   for (const key in codeTable.shape) {
@@ -1301,33 +1400,48 @@ const collectCodeFkeys = ({ codeTable, changeTableAst: { shape } }, currentSchem
       ...column.data.foreignKeys.map((x) => {
         var _a2;
         const columns = [name];
-        const references = {
-          columns,
-          fnOrTable: fnOrTableToString(x.fnOrTable),
-          foreignColumns: x.foreignColumns,
-          options: x.options
-        };
+        const fnOrTable = fnOrTableToString(x.fnOrTable);
         return parseForeignKey(
+          config,
           {
             name: (_a2 = x.options) == null ? void 0 : _a2.name,
-            references
+            references: {
+              columns: [key],
+              fnOrTable,
+              foreignColumns: x.foreignColumns,
+              options: x.options
+            }
+          },
+          {
+            columns,
+            fnOrTable,
+            foreignColumns: x.foreignColumns,
+            options: x.options
           },
-          references,
           currentSchema
         );
       })
     );
   }
   if (codeTable.internal.tableData.constraints) {
-    for (const constraint of codeTable.internal.tableData.constraints) {
-      const { references } = constraint;
-      if (!references)
+    for (const tableConstraint of codeTable.internal.tableData.constraints) {
+      const { references: refs } = tableConstraint;
+      if (!refs)
         continue;
-      references.fnOrTable = fnOrTableToString(references.fnOrTable);
+      const fnOrTable = fnOrTableToString(refs.fnOrTable);
       codeForeignKeys.push(
         parseForeignKey(
-          constraint,
-          references,
+          config,
+          __spreadProps$3(__spreadValues$3({}, tableConstraint), {
+            references: __spreadProps$3(__spreadValues$3({}, refs), {
+              fnOrTable
+            })
+          }),
+          __spreadProps$3(__spreadValues$3({}, refs), {
+            fnOrTable,
+            columns: config.snakeCase ? refs.columns.map(toSnakeCase) : refs.columns,
+            foreignColumns: config.snakeCase ? refs.foreignColumns.map(toSnakeCase) : refs.foreignColumns
+          }),
           currentSchema
         )
       );
@@ -1342,7 +1456,7 @@ const fnOrTableToString = (fnOrTable) => {
   }
   return fnOrTable;
 };
-const parseForeignKey = (codeConstraint, references, currentSchema) => {
+const parseForeignKey = (config, codeConstraint, references, currentSchema) => {
   const { fnOrTable, columns, foreignColumns, options } = references;
   const [schema, table] = getSchemaAndTableFromName(fnOrTable);
   return {
@@ -1350,7 +1464,7 @@ const parseForeignKey = (codeConstraint, references, currentSchema) => {
       foreignSchema: schema != null ? schema : currentSchema,
       foreignTable: table,
       columns,
-      foreignColumns,
+      foreignColumns: config.snakeCase ? foreignColumns.map(toSnakeCase) : foreignColumns,
       match: mapMatchToDb[(options == null ? void 0 : options.match) || "SIMPLE"],
       onUpdate: mapActionToDb[(options == null ? void 0 : options.onUpdate) || "NO ACTION"],
       onDelete: mapActionToDb[(options == null ? void 0 : options.onDelete) || "NO ACTION"]
@@ -1358,8 +1472,12 @@ const parseForeignKey = (codeConstraint, references, currentSchema) => {
     codeConstraint
   };
 };
-const dbForeignKeyToCodeForeignKey = (dbConstraint, dbReferences) => ({
-  name: dbConstraint.name === getConstraintName(dbConstraint.tableName, { references: dbReferences }) ? void 0 : dbConstraint.name,
+const dbForeignKeyToCodeForeignKey = (config, dbConstraint, dbReferences) => ({
+  name: dbConstraint.name === getConstraintName(
+    dbConstraint.tableName,
+    { references: dbReferences },
+    config.snakeCase
+  ) ? void 0 : dbConstraint.name,
   references: {
     columns: dbReferences.columns,
     fnOrTable: `${dbReferences.foreignSchema}.${dbReferences.foreignTable}`,
@@ -1521,7 +1639,7 @@ const processTables = async (ast, structureToAstCtx, domainsMap, adapter, tables
     tableExpressions,
     verifying
   );
-  processForeignKeys(ast, changeTables, currentSchema, tableShapes);
+  processForeignKeys(config, ast, changeTables, currentSchema, tableShapes);
   await Promise.all([
     applyCompareSql(compareSql, adapter),
     compareSqlExpressions(tableExpressions, adapter)
@@ -1731,6 +1849,7 @@ const makeTableShape = (table) => {
 const processTableChange = async (adapter, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, changeTableData, compareSql, compareExpressions, typeCastsCache, verifying) => {
   await processColumns(
     adapter,
+    config,
     structureToAstCtx,
     dbStructure,
     domainsMap,
@@ -1742,7 +1861,7 @@ const processTableChange = async (adapter, structureToAstCtx, dbStructure, domai
     verifying
   );
   const delayedAst = [];
-  processPrimaryKey(delayedAst, changeTableData);
+  processPrimaryKey(config, delayedAst, changeTableData);
   processIndexes(config, changeTableData, delayedAst, ast, compareExpressions);
   processChecks(ast, changeTableData, compareExpressions);
   const { changeTableAst } = changeTableData;
@@ -1832,7 +1951,7 @@ const verifyMigration = async (adapter, config, migrationCode, generateMigration
 };
 
 const report = (ast, config, currentSchema) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   if (!config.logger)
     return;
   const code = [];
@@ -1898,25 +2017,34 @@ const report = (ast, config, currentSchema) => {
           for (const change of changes) {
             if (change.type === "add" || change.type === "drop") {
               const column = change.item;
-              const name = (_g = column.data.name) != null ? _g : key;
               const { primaryKey, indexes, foreignKeys, check } = column.data;
               inner.push(
-                `${change.type === "add" ? green("+ add column") : red("- drop column")} ${name} ${(_h = column.data.alias) != null ? _h : getColumnDbType(column, currentSchema)}${column.data.isNullable ? " nullable" : ""}${primaryKey ? " primary key" : ""}${foreignKeys ? ` references ${foreignKeys.map((fk) => {
+                `${change.type === "add" ? green("+ add column") : red("- drop column")} ${key} ${(_g = column.data.alias) != null ? _g : getColumnDbType(column, currentSchema)}${column.data.isNullable ? " nullable" : ""}${primaryKey ? " primary key" : ""}${foreignKeys ? ` references ${foreignKeys.map((fk) => {
                   return `${fnOrTableToString(
                     fk.fnOrTable
                   )}(${fk.foreignColumns.join(", ")})`;
                 }).join(", ")}` : ""}${(indexes == null ? void 0 : indexes.length) ? indexes.length === 1 ? ", has index" : `, has ${indexes.length} indexes` : ""}${check ? `, checks ${check.sql.toSQL({ values: [] })}` : ""}`
               );
             } else if (change.type === "change") {
-              const name = (_j = (_i = change.from.column) == null ? void 0 : _i.data.name) != null ? _j : key;
+              const name = (_i = (_h = change.from.column) == null ? void 0 : _h.data.name) != null ? _i : key;
               const changes2 = [];
               inner.push(`${yellow("~ change column")} ${name}:`, changes2);
               changes2.push(`${yellow("from")}: `);
-              for (const code2 of change.from.column.toCode("t", true)) {
+              const fromCode = columnToCode(
+                key,
+                change.from.column,
+                config.snakeCase
+              );
+              for (const code2 of fromCode) {
                 addCode(changes2, code2);
               }
               changes2.push(`  ${yellow("to")}: `);
-              for (const code2 of change.to.column.toCode("t", true)) {
+              const toCode = columnToCode(
+                key,
+                change.to.column,
+                config.snakeCase
+              );
+              for (const code2 of toCode) {
                 addCode(changes2, code2);
               }
             } else if (change.type === "rename") {
@@ -2405,11 +2533,12 @@ const processEnumColumn = (column, currentSchema, codeItems) => {
     codeItems.schemas.add(schema);
 };
 const processHasAndBelongsToManyColumn = (column, habtmTables, codeItems) => {
+  var _a, _b;
   const q = column.joinTable;
   const prev = habtmTables.get(q.table);
   if (prev) {
     for (const key in q.shape) {
-      if (q.shape[key] !== prev.shape[key]) {
+      if (q.shape[key].dataType !== ((_a = prev.shape[key]) == null ? void 0 : _a.dataType)) {
         throw new Error(
           `Column ${key} in ${q.table} in hasAndBelongsToMany relation does not match with the relation on the other side`
         );
@@ -2423,11 +2552,12 @@ const processHasAndBelongsToManyColumn = (column, habtmTables, codeItems) => {
   for (const key in joinTable.shape) {
     const column2 = Object.create(joinTable.shape[key]);
     column2.data = __spreadProps$1(__spreadValues$1({}, column2.data), {
+      name: (_b = column2.data.name) != null ? _b : key,
       identity: void 0,
       primaryKey: void 0,
       default: void 0
     });
-    shape[key] = column2;
+    shape[toCamelCase(key)] = column2;
   }
   joinTable.shape = shape;
   joinTable.internal = __spreadProps$1(__spreadValues$1({}, joinTable.internal), {