Refinements to index handling

Improved handling of indexes in isActual and autoupdate.

Author: dave-apex

lib/migration.js

@@ -209,6 +209,52 @@ function mixinMigration(PostgreSQL) {
     });
   };
 
+  PostgreSQL.prototype.isActualIndexes = function (modelName, callback) {
+    debug('modelName %j', modelName);
+    const self = this;
+
+    const model = self._models[modelName];
+
+    self.showIndexes(modelName, (err, asIsModelIndexes) => {
+      if (err) return callback(err);
+
+      debug('asIsModelIndexes %j', asIsModelIndexes);
+
+      const asIsIndexes = generateAsIsIndexCompare(asIsModelIndexes);
+
+      const toBeIndexes = generateToBeIndexCompare(model.settings.indexes);
+      debug('toBeIndexes', toBeIndexes);
+
+      // Look for Differences
+      let differenceFound = false;
+      for (const name in toBeIndexes) {
+        debug('name %j', name);
+        if (asIsIndexes[name] !== toBeIndexes[name]) {
+          debug('asIsIndexes[name] %j', asIsIndexes[name]);
+          debug('toBeIndexes[name] %j', toBeIndexes[name]);
+          differenceFound = true;
+          break;
+        }
+      }
+
+      if (!differenceFound) {
+        for (const name in asIsIndexes) {
+          debug('name %j', name);
+          if (!toBeIndexes[name]) {
+            debug('name not found in toBe %j', name);
+            differenceFound = true;
+            break;
+          }
+        }
+      }
+      if (differenceFound) {
+        debug('differenceFound for %j', modelName);
+      }
+
+      callback(null, !differenceFound);
+    });
+  };
+
   PostgreSQL.prototype.getAddModifyColumns = function (model, actualFields) {
     let sql = [];
     const self = this;
@@ -757,13 +803,16 @@ function mixinMigration(PostgreSQL) {
   function isCaseInsensitiveEqual(val1, val2) {
     return val1.toLowerCase() === val2.toLowerCase();
   }
+
   /*!
    * Case insensitive comparison of object properties
    * @param {Object} properties
    * @param {String} name
    */
   function hasColumnProperty(properties, name) {
-    if (!name) { return false; }
+    if (!name) {
+      return false;
+    }
 
     return (Object.keys(properties)
       .map(function (k) {
@@ -870,17 +919,16 @@ function mixinMigration(PostgreSQL) {
   }
 
   PostgreSQL.prototype.addIndexes = function (model, actualIndexes, options, cb) {
+
     const self = this;
+
     const m = self._models[model];
-    const propNames = Object.keys(m.properties).filter(function (name) {
-      return !!m.properties[name];
-    });
-    const indexNames = m.settings.indexes && Object.keys(m.settings.indexes).filter(function (name) {
-      return !!m.settings.indexes[name];
-    }) || [];
+
+    const schema = self.escapeName(self.schema(model) || 'public');
+
     const sql = [];
+
     const ai = {};
-    const propNameRegEx = new RegExp('^' + self.table(model) + '_([^_]+)_idx');
 
     if (actualIndexes) {
       actualIndexes.forEach(function (i) {
@@ -890,75 +938,52 @@ function mixinMigration(PostgreSQL) {
         }
       });
     }
-    const aiNames = Object.keys(ai);
-
-    // remove indexes
-    aiNames.forEach(function (indexName) {
-      const schema = self.escapeName(self.schema(model) || 'public');
-      const i = ai[indexName];
-      let propName = propNameRegEx.exec(indexName);
-      let si; // index definition from model schema
+    debug('ai %j', ai);
 
-      if (i.primary || (m.properties[indexName] && self.id(model, indexName))) return;
+    const asIsIndexes = generateAsIsIndexCompare(actualIndexes);
+    debug('asIsIndexes %j', asIsIndexes);
 
-      propName = propName && self.propertyName(model, propName[1]) || null;
-      if (!(indexNames.indexOf(indexName) > -1) && !(propName && m.properties[propName] &&
-        m.properties[propName].index)) {
-        sql.push('DROP INDEX ' + schema + '.' + self.escapeName(indexName));
-      } else {
-        // The index was found, verify that database matches what we're expecting.
-        // first: check single column indexes.
-        if (propName) {
-          // If this property has an index definition, verify that it matches
-          if (m.properties[propName] && (si = m.properties[propName].index)) {
-            if (
-              (typeof si === 'object') &&
-              !((!si.type || si.type === ai[indexName].type) && (!si.unique || si.unique === ai[indexName].unique))
-            ) {
-              // Drop the index if the type or unique differs from the actual table
-              sql.push('DROP INDEX ' + schema + '.' + self.escapeName(indexName));
-              delete ai[indexName];
-            }
-          }
-        } else {
-          // second: check other indexes
-          si = normalizeIndexDefinition(m.settings.indexes[indexName]);
-
-          let identical =
-            (!si.type || si.type === i.type) && // compare type
-            ((si.options && !!si.options.unique) === i.unique); // compare unique
-
-          // if this is a multi-column query, verify that the order matches
-          const siKeys = Object.keys(si.keys);
-          if (identical && siKeys.length > 1) {
-            if (siKeys.length !== i.keys.length) {
-              // lengths differ, obviously non-matching
-              identical = false;
-            } else {
-              siKeys.forEach(function (propName, iter) {
-                identical = identical && self.column(model, propName) === i.keys[iter];
-              });
-            }
-          }
+    const toBeIndexes = generateToBeIndexCompare(m.settings.indexes);
+    debug('toBeIndexes %j', toBeIndexes);
 
-          if (!identical) {
-            sql.push('DROP INDEX ' + schema + '.' + self.escapeName(indexName));
-            delete ai[indexName];
-          }
-        }
+    for (const name in asIsIndexes) {
+      debug('name %j', name);
+      if (asIsIndexes[name] !== toBeIndexes[name]) {
+        debug('asIsIndexes[name] %j', asIsIndexes[name]);
+        debug('toBeIndexes[name] %j', toBeIndexes[name]);
+        sql.push('DROP INDEX ' + schema + '.' + self.escapeName(name));
+        delete ai[name];
       }
+    }
+    debug('sql after drop indexes %j', sql);
+    debug('ai after drop indexes %j', ai);
+
+    const propNames = Object.keys(m.properties).filter(function (name) {
+      return !!m.properties[name];
     });
+    debug('propNames %j', propNames);
+
+    const indexNames =
+      (m.settings.indexes &&
+        Object.keys(m.settings.indexes).filter(function (name) {
+          return !!m.settings.indexes[name];
+        })) ||
+      [];
+    debug('indexNames %j', indexNames);
 
     // add single-column indexes
     propNames.forEach(function (propName) {
+      debug('propName %j', propName);
       const i = m.properties[propName].index;
       if (!i) {
         return;
       }
+      debug('i %j', i);
 
       // The index name used should match the default naming scheme
       // by postgres: <column>_<table>_idx
       const iName = [self.table(model), self.column(model, propName), 'idx'].join('_');
+      debug('iName %j', iName);
 
       const found = ai[iName]; // && ai[iName].info;
       if (!found) {
@@ -972,12 +997,22 @@ function mixinMigration(PostgreSQL) {
           kind = i.kind;
         }
 
-        if (!kind && !type && typeof i === 'object' || i.unique && i.unique === true) {
+        if ((!kind && !type && typeof i === 'object') || (i.unique && i.unique === true)) {
           kind = ' UNIQUE ';
         }
 
-        sql.push('CREATE ' + kind + ' INDEX ' + self.escapeName(iName) + ' ON ' + self.tableEscaped(model) +
-          type + ' ( ' + pName + ' )');
+        sql.push(
+          'CREATE ' +
+          kind +
+          ' INDEX ' +
+          self.escapeName(iName) +
+          ' ON ' +
+          self.tableEscaped(model) +
+          type +
+          ' ( ' +
+          pName +
+          ' )'
+        );
       }
     });
 
@@ -988,9 +1023,11 @@ function mixinMigration(PostgreSQL) {
       if (!found) {
         i = normalizeIndexDefinition(i);
         const iName = self.escapeName(indexName);
-        const columns = i.keys.map(function (key) {
-          return self.escapeName(self.column(model, key[0])) + (key[1] ? ' ' + key[1] : '');
-        }).join(', ');
+        const columns = i.keys
+          .map(function (key) {
+            return self.escapeName(self.column(model, key[0])) + (key[1] ? ' ' + key[1] : '');
+          })
+          .join(', ');
 
         let type = '';
         let kind = '';
@@ -1005,8 +1042,9 @@ function mixinMigration(PostgreSQL) {
           kind = ' UNIQUE ';
         }
 
-        sql.push('CREATE ' + kind + ' INDEX ' + iName + ' ON ' + self.tableEscaped(model) +
-          type + ' ( ' + columns + ')');
+        sql.push(
+          'CREATE ' + kind + ' INDEX ' + iName + ' ON ' + self.tableEscaped(model) + type + ' ( ' + columns + ')'
+        );
       }
     });
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apexdesigner/loopback-connector-postgresql",
-  "version": "7.0.8",
+  "version": "7.0.9",
   "description": "Loopback PostgreSQL Connector",
   "keywords": [
     "LoopBack",
@@ -33,7 +33,7 @@
     "bluebird": "^3.4.6",
     "chalk": "^4.0.0",
     "debug": "^4.1.1",
-    "loopback-connector": "npm:@apexdesigner/loopback-connector@^6.0.0",
+    "loopback-connector": "npm:@apexdesigner/loopback-connector@^6.1.4",
     "pg": "^8.0.2",
     "strong-globalize": "^6.0.0",
     "uuid": "^9.0.0"