init source

node_modules/sequelize/lib/dialects/postgres/query-interface.js

@@ -0,0 +1,157 @@
+'use strict';
+
+const DataTypes = require('../../data-types');
+const Promise = require('../../promise');
+const QueryTypes = require('../../query-types');
+const _ = require('lodash');
+
+
+/**
+ Returns an object that handles Postgres special needs to do certain queries.
+
+ @class QueryInterface
+ @static
+ @private
+ */
+
+/**
+   * Ensure enum and their values.
+   *
+   * @param {QueryInterface} qi
+   * @param {string} tableName  Name of table to create
+   * @param {Object} attributes Object representing a list of normalized table attributes
+   * @param {Object} [options]
+   * @param {Model}  [model]
+   *
+   * @returns {Promise}
+   * @private
+   */
+function ensureEnums(qi, tableName, attributes, options, model) {
+  const keys = Object.keys(attributes);
+  const keyLen = keys.length;
+
+  let sql = '';
+  let promises = [];
+  let i = 0;
+
+  for (i = 0; i < keyLen; i++) {
+    const attribute = attributes[keys[i]];
+    const type = attribute.type;
+
+    if (
+      type instanceof DataTypes.ENUM ||
+      type instanceof DataTypes.ARRAY && type.type instanceof DataTypes.ENUM //ARRAY sub type is ENUM
+    ) {
+      sql = qi.QueryGenerator.pgListEnums(tableName, attribute.field || keys[i], options);
+      promises.push(qi.sequelize.query(
+        sql,
+        Object.assign({}, options, { plain: true, raw: true, type: QueryTypes.SELECT })
+      ));
+    }
+  }
+
+  return Promise.all(promises).then(results => {
+    promises = [];
+    let enumIdx = 0;
+
+    // This little function allows us to re-use the same code that prepends or appends new value to enum array
+    const addEnumValue = (field, value, relativeValue, position = 'before', spliceStart = promises.length) => {
+      const valueOptions = _.clone(options);
+      valueOptions.before = null;
+      valueOptions.after = null;
+
+      switch (position) {
+        case 'after':
+          valueOptions.after = relativeValue;
+          break;
+        case 'before':
+        default:
+          valueOptions.before = relativeValue;
+          break;
+      }
+
+      promises.splice(spliceStart, 0, () => {
+        return qi.sequelize.query(qi.QueryGenerator.pgEnumAdd(
+          tableName, field, value, valueOptions
+        ), valueOptions);
+      });
+    };
+
+    for (i = 0; i < keyLen; i++) {
+      const attribute = attributes[keys[i]];
+      const type = attribute.type;
+      const enumType = type.type || type;
+      const field = attribute.field || keys[i];
+
+      if (
+        type instanceof DataTypes.ENUM ||
+        type instanceof DataTypes.ARRAY && enumType instanceof DataTypes.ENUM //ARRAY sub type is ENUM
+      ) {
+        // If the enum type doesn't exist then create it
+        if (!results[enumIdx]) {
+          promises.push(() => {
+            return qi.sequelize.query(qi.QueryGenerator.pgEnum(tableName, field, enumType, options), Object.assign({}, options, { raw: true }));
+          });
+        } else if (!!results[enumIdx] && !!model) {
+          const enumVals = qi.QueryGenerator.fromArray(results[enumIdx].enum_value);
+          const vals = enumType.values;
+
+          // Going through already existing values allows us to make queries that depend on those values
+          // We will prepend all new values between the old ones, but keep in mind - we can't change order of already existing values
+          // Then we append the rest of new values AFTER the latest already existing value
+          // E.g.: [1,2] -> [0,2,1] ==> [1,0,2]
+          // E.g.: [1,2,3] -> [2,1,3,4] ==> [1,2,3,4]
+          // E.g.: [1] -> [0,2,3] ==> [1,0,2,3]
+          let lastOldEnumValue;
+          let rightestPosition = -1;
+          for (let oldIndex = 0; oldIndex < enumVals.length; oldIndex++) {
+            const enumVal = enumVals[oldIndex];
+            const newIdx = vals.indexOf(enumVal);
+            lastOldEnumValue = enumVal;
+
+            if (newIdx === -1) {
+              continue;
+            }
+
+            const newValuesBefore = vals.slice(0, newIdx);
+            const promisesLength = promises.length;
+            // we go in reverse order so we could stop when we meet old value
+            for (let reverseIdx = newValuesBefore.length - 1; reverseIdx >= 0; reverseIdx--) {
+              if (~enumVals.indexOf(newValuesBefore[reverseIdx])) {
+                break;
+              }
+
+              addEnumValue(field, newValuesBefore[reverseIdx], lastOldEnumValue, 'before', promisesLength);
+            }
+
+            // we detect the most 'right' position of old value in new enum array so we can append new values to it
+            if (newIdx > rightestPosition) {
+              rightestPosition = newIdx;
+            }
+          }
+
+          if (lastOldEnumValue && rightestPosition < vals.length - 1) {
+            const remainingEnumValues = vals.slice(rightestPosition + 1);
+            for (let reverseIdx = remainingEnumValues.length - 1; reverseIdx >= 0; reverseIdx--) {
+              addEnumValue(field, remainingEnumValues[reverseIdx], lastOldEnumValue, 'after');
+            }
+          }
+
+          enumIdx++;
+        }
+      }
+    }
+
+    return promises
+      .reduce((promise, asyncFunction) => promise.then(asyncFunction), Promise.resolve())
+      .tap(() => {
+        // If ENUM processed, then refresh OIDs
+        if (promises.length) {
+          return qi.sequelize.dialect.connectionManager._refreshDynamicOIDs();
+        }
+      });
+  });
+}
+
+
+exports.ensureEnums = ensureEnums;