Polymorphic relations and MultiMapper

[rhys-vdw]

Should be fairly simple in the belongsTo end.

hasMany and belongsToMany are more complicated:

Images.relations({
  owners() return this.polymorphicBelongsToMany(posts, users, pages, comments, { typeAttribute: 'owner_type', idAttribute: 'owner_id' });
})

const images = [
  { id: 5, owner_type: 'posts', owner_id: 6, path: '...' },
  { id: 24, owner_type: 'posts', owner_id: 8, path: '...' },
  { id: 5, owner_type: 'users', owner_id: 24, path: '...' },
]

// `fetch` returns a `MultiMapper` that delegates to each of the required mappers.
Images.relation('owners').of(images).fetch().then(({ posts, users }) => {
  // whatever
});

class MultiMapper extends Chain {

  initialize() {
    this.setState({ mappers: {} })
  }

  mappers(...mappers) {
    const next = keyBy(flatten(mappers), m => m.getName())
  }

  delegateAsync(method, ...args) {
    const promises = mapValues(this.state.mappers, m => m[method](...args))
    return Promise.props(promises);
  }

  delegate(method, ...args) {
    const mappers = mapValues(this.state.mappers, m => m[method](...args))
    this.setState({ mappers })
  }

}

function delegateMethods(methodNames, delegationMethod) {
  return transform(methodNames, (results, name) => {
    result[name] = function(...args) {
      this[delegationMethod](name, args);
    }
  }, {});
}

const asyncMethods = ['fetch', 'update', 'insert', 'updateAll', 'destroyAll'];
const syncMethods = ['require', 'attributes'];

assign(
  MultMapper.prototype,
  delegateMethods(syncMethods, 'delegate'),
  delegateMethods(syncMethods, 'delegateAsync')
);

export default MultiMapper; 

[rhys-vdw]

This can be supported more easily using a Proxy instance.