Add extra dependencies and resolvers.

lib/fixture-generator.js

@@ -63,7 +63,7 @@ FixtureGenerator.prototype.create = function resolveQueriesAndCreateRecords(data
   options = options || {};
 
   var withSpecIds = generateSpecIds(dataConfig);
-  var prioritized = prioritize(withSpecIds);
+  var prioritized = prioritize(withSpecIds, options);
 
   if (prioritized instanceof Error) {
     return fail(prioritized, callback);
@@ -74,7 +74,7 @@ FixtureGenerator.prototype.create = function resolveQueriesAndCreateRecords(data
 
   var mainPromise = bluebird.all(fkQueries).then(function createRecords() {
     return bluebird.reduce(prioritized, function(buildingFinalResult, priorityLevel) {
-      priorityLevel = resolveDependencies(buildingFinalResult, priorityLevel);
+      priorityLevel = resolveDependencies(buildingFinalResult, priorityLevel, options);
       priorityLevel = unescape(priorityLevel);
       var priorityLevelPromises = insertRecords(knexInst, priorityLevel, options.unique, options.showWarning);
       return bluebird.all(priorityLevelPromises).then(function(levelResults) {

lib/prioritize.js

@@ -59,11 +59,13 @@ var util = require('./util');
  *
  * [['Users', '0'], ['Items', '1', 'bar']]
  */
-function getNeeds(entry) {
+function getNeeds(table, entry, extraDependencies) {
+  const extra = extraDependencies ? extraDependencies(table, entry) || [] : [];
+
   if(_.isString(entry)) {
-    return getNeedsString(entry);
+    return extra.concat(getNeedsString(entry));
   } else {
-    return getNeedsObject(entry);
+    return extra.concat(getNeedsObject(entry));
   }
 }
 
@@ -114,8 +116,8 @@ function getRemainingNeeds(obj) {
  * determines if the entry's dependencies can be satisfied
  * from the prerequisites
  */
-function satisfied(entry, availablePreReqs) {
-  var needs = getNeeds(entry);
+function satisfied(table, entry, availablePreReqs, extraDependencies) {
+  var needs = getNeeds(table, entry, extraDependencies);
   var missingReqs = [];
 
   return [_.every(needs, function(need) {
@@ -145,8 +147,9 @@ function addNewPreReqs(newReqs, currentReqs) {
  * and pulls out entries as their dependencies get satisfied
  * into a prioritized array
  */
-module.exports = function prioritize(config) {
+module.exports = function prioritize(config, options) {
   config = _.clone(config);
+  var extraDependencies = options ? options.extraDependencies : null;
   var prioritized = [];
   var availablePreReqs = {};
   var missingReqs = [];
@@ -159,7 +162,7 @@ module.exports = function prioritize(config) {
       entries = config[table] = util.asArray(entries);
 
       entries.forEach(function(entry, index) {
-        var ret = satisfied(entry, availablePreReqs);
+        var ret = satisfied(table, entry, availablePreReqs, extraDependencies);
 
         if (ret[0]) {
           levelEntries[table] = levelEntries[table] || [];

lib/resolve-dependencies.js

@@ -32,15 +32,19 @@ function resolve(value, availablePreReqs) {
   return resolvedDep && resolvedDep[property] || value;
 }
 
-module.exports = function resolveDependencies(availablePreReqs, toBeResolved) {
+module.exports = function resolveDependencies(availablePreReqs, toBeResolved, options) {
   toBeResolved = _.clone(toBeResolved);
+  var extraResolver = options ? options.extraResolver : null;
 
   _.forIn(toBeResolved, function(entries, table) {
     toBeResolved[table] = entries.map(function(entry) {
       if(_.isString(entry)) {
         return resolve(entry, availablePreReqs);
       }
       else if(_.isObject(entry)) {
+        var extraResolve = extraResolver ? extraResolver(table, entry, function (value) { return resolve(value, availablePreReqs); }) : null;
+        if (extraResolve) return entry;
+
         _.forIn(entry, function(value, property, entry) {
           // entry[property] = resolve(value, availablePreReqs);
           if (_.isArray(value)) {

test/unit/prioritize-spec.js

@@ -45,6 +45,50 @@ describe('prioritize', function() {
       }]);
     });
 
+    it('should prioritize with extra dependencies', function() {
+      var config = {
+        Users: {
+          username: 'bob',
+          specId: 'u0'
+        },
+        Challenges: [{
+          type: 'User',
+          value: 'u0',
+          specId: 'c0'
+        },{
+          type: 'Foo',
+          value: 'bla',
+          specId: 'c1'
+        }]
+      };
+
+      var options = {
+        extraDependencies: function (table, entry) {
+          if (table != 'Challenges') return;
+          if (entry.type != 'User') return;
+          return [['Users', entry.value]];
+        }
+      };
+
+      expect(prioritize(config, options)).to.eql([{
+        Challenges: [{
+          specId: "c1",
+          type: "Foo",
+          value: "bla"
+        }],
+        Users: [{
+          username: 'bob',
+          specId: 'u0'
+        }]
+      }, {
+        Challenges: [{
+          type: 'User',
+          value: 'u0',
+          specId: 'c0'
+        }]
+      }]);
+    });
+
     it('should prioritize later dependencies correctly', function() {
       var config = {
         Users: [{

test/unit/resolve-dependencies-spec.js

@@ -36,6 +36,39 @@ describe('resolve-dependencies', function() {
     });
   });
 
+  it('should resolve extra dependencies', function() {
+    var toBeResolved = {
+      Challenges: [{
+        type: 'User',
+        foo: 'u0'
+      }]
+    };
+
+    var previouslyResolved = {
+      Users: [{
+        id: 4,
+        specId: 'u0'
+      }]
+    };
+
+    var options = {
+      extraResolver: function (table, entry, resolve) {
+        if (table != 'Challenges') return;
+        if (entry.type != 'User') return;
+        entry.foo = resolve('Users:' + entry.foo);
+        return entry;
+      }
+    };
+
+    var resolved = resolveDependencies(previouslyResolved, toBeResolved, options);
+    expect(resolved).to.eql({
+      Challenges: [{
+        type: 'User',
+        foo: 4
+      }]
+    });
+  });
+
   it('should resolve a non-default property', function() {
     var toBeResolved = {
       Challenges: [{