rake-db 2.1.15 → 2.1.17

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # rake-db
 
+## 2.1.17
+
+### Patch Changes
+
+- Support composite primary key by setting primaryKey on multiple columns
+
+## 2.1.16
+
+### Patch Changes
+
+- Updated dependencies
+  - pqb@0.7.12
+
 ## 2.1.15
 
 ### Patch Changes

package/dist/index.d.ts

@@ -28,10 +28,10 @@ declare type ChangeOptions = {
     usingUp?: RawExpression;
     usingDown?: RawExpression;
 };
-declare type ChangeArg = ColumnType | ['default', unknown | RawExpression] | ['nullable', boolean] | ['comment', string | null] | ['compression', string] | ['foreignKey', ForeignKey<string, string[]>] | ['index', Omit<SingleColumnIndexOptions, 'column'>];
+declare type ChangeArg = ColumnType | ['default', unknown | RawExpression] | ['nullable', boolean] | ['comment', string | null] | ['compression', string] | ['primaryKey', boolean] | ['foreignKey', ForeignKey<string, string[]>] | ['index', Omit<SingleColumnIndexOptions, 'column'>];
 declare type TableChangeMethods = typeof tableChangeMethods;
 declare const tableChangeMethods: {
-    raw: (sql: string, ...values: unknown[]) => RawExpression<ColumnType<unknown, pqb.Operators, unknown>>;
+    raw: (sql: string, values?: false | Record<string, unknown> | undefined) => RawExpression<ColumnType<unknown, pqb.Operators, unknown>>;
     add: typeof add;
     drop: typeof add;
     change(from: ChangeArg, to: ChangeArg, options?: ChangeOptions): ChangeItem;

package/dist/index.esm.js

@@ -219,7 +219,7 @@ var __spreadValues$3 = (a, b) => {
   return a;
 };
 var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
-const columnToSql = (key, item, { values }) => {
+const columnToSql = (key, item, values, hasMultiplePrimaryKeys) => {
   const line = [`"${key}" ${item.toSQL()}`];
   if (item.data.compression) {
     line.push(`COMPRESSION ${item.data.compression}`);
@@ -227,7 +227,7 @@ const columnToSql = (key, item, { values }) => {
   if (item.data.collate) {
     line.push(`COLLATE ${quote(item.data.collate)}`);
   }
-  if (item.isPrimaryKey) {
+  if (item.isPrimaryKey && !hasMultiplePrimaryKeys) {
     line.push("PRIMARY KEY");
   } else if (!item.isNullable) {
     line.push("NOT NULL");
@@ -479,29 +479,9 @@ const types = Object.assign(Object.create(columnTypes), {
   raw
 });
 const createTable = async (migration, up, tableName, options, fn) => {
-  var _a, _b;
   const shape = getColumnTypes(types, fn);
   const tableData = getTableData();
-  const { noPrimaryKey } = migration.options;
-  if (!options.noPrimaryKey && (!noPrimaryKey || noPrimaryKey !== "ignore")) {
-    let hasPrimaryKey = !!((_b = (_a = tableData.primaryKey) == null ? void 0 : _a.columns) == null ? void 0 : _b.length);
-    if (!hasPrimaryKey) {
-      for (const key in shape) {
-        if (shape[key].isPrimaryKey) {
-          hasPrimaryKey = true;
-          break;
-        }
-      }
-    }
-    if (!hasPrimaryKey) {
-      const message = `Table ${tableName} has no primary key`;
-      if (!noPrimaryKey || noPrimaryKey === "error") {
-        throw new Error(message);
-      } else {
-        console.warn(message);
-      }
-    }
-  }
+  validatePrimaryKey(migration, options, tableData, shape, tableName);
   if (!up) {
     const { dropMode } = options;
     await migration.query(
@@ -510,19 +490,23 @@ const createTable = async (migration, up, tableName, options, fn) => {
     return;
   }
   const lines = [];
+  applyMultiplePrimaryKeys(shape, tableData);
   const state = {
     migration,
     tableName,
     values: [],
     indexes: [],
-    comments: []
+    comments: [],
+    tableData
   };
   for (const key in shape) {
     const item = shape[key];
     addColumnIndex(state.indexes, key, item);
     addColumnComment(state.comments, key, item);
-    lines.push(`
-  ${columnToSql(key, item, state)}`);
+    lines.push(
+      `
+  ${columnToSql(key, item, state.values, tableData.primaryKey)}`
+    );
   }
   if (tableData.primaryKey) {
     lines.push(`
@@ -546,6 +530,44 @@ const createTable = async (migration, up, tableName, options, fn) => {
     );
   }
 };
+const validatePrimaryKey = (migration, options, tableData, shape, tableName) => {
+  var _a, _b;
+  const { noPrimaryKey } = migration.options;
+  if (!options.noPrimaryKey && (!noPrimaryKey || noPrimaryKey !== "ignore")) {
+    let hasPrimaryKey = !!((_b = (_a = tableData.primaryKey) == null ? void 0 : _a.columns) == null ? void 0 : _b.length);
+    if (!hasPrimaryKey) {
+      for (const key in shape) {
+        if (shape[key].isPrimaryKey) {
+          hasPrimaryKey = true;
+          break;
+        }
+      }
+    }
+    if (!hasPrimaryKey) {
+      const message = `Table ${tableName} has no primary key`;
+      if (!noPrimaryKey || noPrimaryKey === "error") {
+        throw new Error(message);
+      } else {
+        console.warn(message);
+      }
+    }
+  }
+};
+const applyMultiplePrimaryKeys = (shape, tableData) => {
+  const columns = [];
+  for (const key in shape) {
+    if (shape[key].isPrimaryKey) {
+      columns.push(key);
+    }
+  }
+  if (columns.length <= 1)
+    return;
+  if (!tableData.primaryKey) {
+    tableData.primaryKey = { columns };
+  } else {
+    tableData.primaryKey.columns.unshift(...columns);
+  }
+};
 
 var __defProp$1 = Object.defineProperty;
 var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
@@ -629,11 +651,33 @@ const tableChangeMethods = {
   }
 };
 const changeTable = async (migration, up, tableName, options, fn) => {
+  var _a;
   resetTableData();
   resetChangeTableData();
   const tableChanger = Object.create(columnTypes);
   Object.assign(tableChanger, tableChangeMethods);
   const changeData = (fn == null ? void 0 : fn(tableChanger)) || {};
+  const addPrimaryKeys = {
+    columns: []
+  };
+  const dropPrimaryKeys = {
+    columns: []
+  };
+  for (const key in changeData) {
+    const item = changeData[key];
+    if (Array.isArray(item)) {
+      const [action] = item;
+      if (action === "add") {
+        if (item[1].isPrimaryKey) {
+          addPrimaryKeys.columns.push(key);
+        }
+      } else if (action === "drop") {
+        if (item[1].isPrimaryKey) {
+          dropPrimaryKeys.columns.push(key);
+        }
+      }
+    }
+  }
   const state = {
     migration,
     up,
@@ -642,37 +686,70 @@ const changeTable = async (migration, up, tableName, options, fn) => {
     values: [],
     indexes: [],
     dropIndexes: [],
-    comments: []
+    comments: [],
+    addPrimaryKeys,
+    dropPrimaryKeys
   };
   if (options.comment !== void 0) {
     await changeActions.tableComment(state, tableName, options.comment);
   }
   for (const key in changeData) {
-    const result = changeData[key];
-    if (Array.isArray(result)) {
-      const [action] = result;
+    const item = changeData[key];
+    if (Array.isArray(item)) {
+      const [action] = item;
       if (action === "change") {
-        const [, from, to, options2] = result;
+        const [, from, to, options2] = item;
         changeActions.change(state, up, key, from, to, options2);
       } else if (action === "rename") {
-        const [, name] = result;
+        const [, name] = item;
         changeActions.rename(state, up, key, name);
       } else if (action) {
-        const [action2, item, options2] = result;
-        changeActions[action2](state, up, key, item, options2);
+        const [action2, columnType, options2] = item;
+        changeActions[action2](state, up, key, columnType, options2);
       }
     }
   }
+  const prependAlterTable = [];
+  let addedDownKey = false;
   changeTableData[up ? "drop" : "add"].forEach((tableData) => {
-    handleTableData(state, false, tableName, tableData);
+    if (tableData.primaryKey) {
+      addedDownKey = true;
+      const keys = state[up ? "dropPrimaryKeys" : "addPrimaryKeys"];
+      keys.columns.push(...tableData.primaryKey.columns);
+      keys.options = tableData.primaryKey.options;
+    }
+    state.dropIndexes.push(...tableData.indexes);
+    prependAlterTable.push(...getForeignKeysLines(state, false, tableData));
   });
+  const dropKeys = state[up ? "dropPrimaryKeys" : "addPrimaryKeys"];
+  if (addedDownKey || dropKeys.change || dropKeys.columns.length > 1) {
+    const name = ((_a = dropKeys.options) == null ? void 0 : _a.name) || `${tableName}_pkey`;
+    prependAlterTable.push(`DROP CONSTRAINT "${name}"`);
+  }
+  let addedUpKey = false;
   changeTableData[up ? "add" : "drop"].forEach((tableData) => {
-    handleTableData(state, true, tableName, tableData);
+    if (tableData.primaryKey) {
+      addedUpKey = true;
+      const keys = state[up ? "addPrimaryKeys" : "dropPrimaryKeys"];
+      keys.columns.push(...tableData.primaryKey.columns);
+      keys.options = tableData.primaryKey.options;
+    }
+    state.indexes.push(...tableData.indexes);
+    state.alterTable.push(...getForeignKeysLines(state, true, tableData));
   });
-  if (state.alterTable.length) {
+  const addKeys = state[up ? "addPrimaryKeys" : "dropPrimaryKeys"];
+  if (addedUpKey || addKeys.change || addKeys.columns.length > 1) {
+    state.alterTable.push(`ADD ${primaryKeyToSql(addKeys)}`);
+  }
+  if (prependAlterTable.length || state.alterTable.length) {
     await migration.query(
       `ALTER TABLE ${quoteTable(tableName)}
-  ${state.alterTable.join(",\n  ")}`
+  ${[
+        ...prependAlterTable,
+        ...state.alterTable.map(
+          (item) => typeof item === "string" ? item : item(state)
+        )
+      ].join(",\n  ")}`
     );
   }
   await migrateIndexes(state, state.dropIndexes, false);
@@ -697,7 +774,14 @@ const changeActions = {
       addColumnComment(state.comments, key, item);
     }
     if (up) {
-      state.alterTable.push(`ADD COLUMN ${columnToSql(key, item, state)}`);
+      state.alterTable.push(
+        (state2) => `ADD COLUMN ${columnToSql(
+          key,
+          item,
+          state2.values,
+          (state2.up ? state2.addPrimaryKeys : state2.dropPrimaryKeys).columns.length > 1
+        )}`
+      );
     } else {
       state.alterTable.push(
         `DROP COLUMN "${key}"${(options == null ? void 0 : options.dropMode) ? ` ${options.dropMode}` : ""}`
@@ -732,6 +816,11 @@ const changeActions = {
         `ALTER COLUMN "${key}" SET COMPRESSION ${to.compression || "DEFAULT"}`
       );
     }
+    if (from.primaryKey || to.primaryKey) {
+      const primaryKey = state[up && to.primaryKey || !up && from.primaryKey ? "addPrimaryKeys" : "dropPrimaryKeys"];
+      primaryKey.columns.push(key);
+      primaryKey.change = true;
+    }
     const fromFkey = from.foreignKey;
     const toFkey = to.foreignKey;
     if (fromFkey || toFkey) {
@@ -813,6 +902,7 @@ const getChangeProperties = (item) => {
       nullable: item.isNullable,
       comment: item.data.comment,
       compression: item.data.compression,
+      primaryKey: item.isPrimaryKey,
       foreignKey: item.data.foreignKey,
       index: item.data.index
     };
@@ -824,33 +914,21 @@ const getChangeProperties = (item) => {
       nullable: item[0] === "nullable" ? item[1] : void 0,
       comment: item[0] === "comment" ? item[1] : void 0,
       compression: item[0] === "compression" ? item[1] : void 0,
+      primaryKey: item[0] === "primaryKey" ? item[1] : void 0,
       foreignKey: item[0] === "foreignKey" ? item[1] : void 0,
       index: item[0] === "index" ? item[1] : void 0
     };
   }
 };
-const handleTableData = (state, up, tableName, tableData) => {
-  var _a;
-  if (tableData.primaryKey) {
-    if (up) {
-      state.alterTable.push(`ADD ${primaryKeyToSql(tableData.primaryKey)}`);
-    } else {
-      const name = ((_a = tableData.primaryKey.options) == null ? void 0 : _a.name) || `${tableName}_pkey`;
-      state.alterTable.push(`DROP CONSTRAINT "${name}"`);
-    }
-  }
-  if (tableData.indexes.length) {
-    state[up ? "indexes" : "dropIndexes"].push(...tableData.indexes);
-  }
-  if (tableData.foreignKeys.length) {
-    tableData.foreignKeys.forEach((foreignKey) => {
-      const action = up ? "ADD" : "DROP";
-      state.alterTable.push(
-        `
-  ${action} ${constraintToSql(state.tableName, up, foreignKey)}`
-      );
-    });
-  }
+const getForeignKeysLines = (state, up, tableData) => {
+  return tableData.foreignKeys.map(
+    (foreignKey) => `
+  ${up ? "ADD" : "DROP"} ${constraintToSql(
+      state.tableName,
+      up,
+      foreignKey
+    )}`
+  );
 };
 const getRawOrValue = (item, values) => {
   return typeof item === "object" && item && isRaw(item) ? getRaw(item, values) : quote(item);