I've been thinking and I'm not convinced it's good enough to just trust that the 2 last_customer_id values will stay in sync all on their own, and if they don't that is going to be pretty bad for our trust in the dual-write strategy. Here's a possible solution...

In our model proxy's proxify function, we'd check the first argument to see if it had been "decorated" with a special argument containing a SPECIAL_FLAG. (The decoration would be done in our marshal setup, in the "supermodel" file.) If there, we store off the value and remove the special argument from args before calling the actual proxied methods. And if that SPECIAL_FLAG was set, we attach the results of the primary action as a final argument passed to the secondary action. (We could even have the value of the SPECIAL_FLAG be a function to map what value from the primary's result we actually want to pass to the secondary.)

Example:

function proxify(method, options) {
  return function() {
    const args = (arguments.length === 1) ? [arguments[0]] : Array.apply(null, arguments);
    let attachPrimary = false;

    if (args[0] && args[0].ATTACH_PRIMARY_RESULT) {
      attachPrimary = args.shift();
    }

    return callMethod(options.primaryModel, method, args).then((result) => {
      if (!options.secondary || !_.isFunction(options.secondaryModel[method])) {
        return result;
      }

      if (attachPrimary) {
        args.push(attachPrimary(result));
      }

      // don't return here and swallow errors so that secondary call is non-blocking
      callMethod(options.secondaryModel, method, args).catch((err) => {
        options.logger.error(`[Eriksen] Captured error on secondary model: ${options.secondary}#${method}`, err);
      });

      return result;
    });
  };
}

So in our "supermodel" file where we instantiate a new Eriksen marshaler, we might have:

const marshal = new Eriksen('accounts');

marshal.addModel('cassandra', require('lib/models/cassandra/accounts'));
marshal.addModel('aws', require('lib/models/aws/accounts'));

marshal.configure({ primary: 'cassandra', secondary: 'aws' });

module.exports = marshal.proxy;

And between configuring the proxy and exporting it, we would decorate the create function:

marshal.configure({ primary: 'cassandra', secondary: 'aws' });

proxyCreateAccount = marshal.proxy.createAccount
marshal.proxy.createAccount = function(account) {
  const args = (arguments.length === 1) ? [arguments[0]] : Array.apply(null, arguments);
  
  // add a new argument to the front of the array with a FLAG and a fn to
  // define what data should be passed along from the primary results
  args.unshift({
    ATTACH_PRIMARY_RESULT: (result) => result.results.customer_id
  });

  proxyCreateAccount.apply(marshal.proxy, args);
}

module.exports = marshal.proxy;

Finally, the actual cassandra and aws versions of createAccount would have to change slightly:

// from this:
model.createAccount = function(account) {
  // get next customer id
  // create account etc.
}

// to this:
model.createAccount = function(account, customerId) {
  if (typeof customerId === 'undefined') {
    customerId = getNextCustomerIdOrWhateverIDK();
  }
  // create account etc.
};

Had a few things bouncing in my head that were stressing me out, just need to get them down to discuss next week:

• I think we have to change the login and account creation throttling we're doing with Redis, slightly. It seems like COPS has some issues around setting up AWS db stuff in the other regions, but even more interesting than that, we can't have both the Cassandra and AWS models using a single store for throttling or else we'll be double-counting each event, once from primary and once from secondary. Probably just need to use Eriksen there and continue using C* for SPE, which will also separate those streams and prevent double-counting.
• Related: how do we handle the account history log? We don't want both models to write to it, but we don't want to leave things out of the AWS models and then scramble to implement things when we switch over...
• Related also: how do we handle actual logging from within the models? I know we set up a separate logger for Eriksen to use directly, but I think we need a way to tell the secondary model in particular to write to a different file from within its code, which will be interesting to figure out without breaking down and having the models know about Eriksen or know whether they are primary/secondary or something. Not sure but something to figure out.