@zeroasterisk
When it goes to meteor collections, yes, the tracker should trigger refresh and the container will reload, but in my case, the data source is not reactive.
So the question is, how do I return the result of a Meteor.call inside createContainer? Consider this example:

export default ProfilesContainer = createContainer(({ params }) => {
  Meteor.call('profiles.fetch', {}, (err, result) => {
    // how to return result from callback to the createContainer scope? 
  })
  return {
    data: result // need result from callback here
  }
}, ProfilesComponent)

I could resolve this, byt doing a sync call, like this:

export default ProfilesContainer = createContainer(({ params }) => {
  const result = Meteor.call('profiles.fetch', {})
  return {
    data: result
  }
}, ProfilesComponent)

But, according to Meteor docs, that will work only for stubs:
"On the client, if you do not pass a callback and you are not inside a stub, call will return undefined, and you will have no way to get the return value of the method. That is because the client doesn’t have fibers, so there is not actually any way it can block on the remote execution of a method."
http://docs.meteor.com/api/methods.html#Meteor-call

On the server, I can use Meteor.wrapAsync, to return a result from async call. Here is my server method:

import seraph from 'seraph'

const Neo4j = seraph({
  user: this.process.env.NEO4J_USER,
  pass: this.process.env.NEO4J_PASS
})

Meteor.methods({
  'profiles.fetch'(params) {
    let cypher = "MATCH (p:Profiles) RETURN p"
    let wrapper = Meteor.wrapAsync((params, callback) => {
      Neo4j.query(cypher, params, callback)
    })
    let result = wrapper(params)
    return result
  }
})

Unfortunately, this will not work on the client - again the callback is required:
"On the server, the wrapped function can be used either synchronously (without passing a callback) or asynchronously (when a callback is passed). On the client, a callback is always required; errors will be logged if there is no callback."
http://docs.meteor.com/api/core.html#Meteor-wrapAsync

With @arunoda's react-komposer I can solve this on the client side using onData function inside the callback:

import {useDeps, composeWithTracker, composeAll} from 'mantra-core'

export const composer = ({context}, onData) => {
  const {Meteor} = context()
  Meteor.call('profiles.fetch', {}, function(err, data) {
      onData(null, {data})
  })
}
export default composeAll(
  composeWithTracker(composer),
  useDeps()
)(ProfilesComponent)

Uh oh!

React Komposer vs createContainer? #3

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions