Add dynamic arguments to factories about discuss HOT 17 OPEN

export default Factory.extend({
  title: 'Lorem ipsum',

  traits: {
    withAuthor() {
      this.model.update('author', server.create('author'));
    },
    
    withComments(count) {
      this.server.createList('comment', count, { post: this.model });
    },
  }
});


// usage
server.createList('post', 3, ({ traits }) => {
  traits.withAuthor();
  traits.withComments(3);
});

// mirage/factories/post.js
export default Factory.extend({
  title: 'Lorem ipsum',
  published: true,

  // Old syntax still works
  asDraft: trait({
    published: false,
  }),

  // New syntax, with parameters, but still familiar
  withLikes: trait((likeCount) => ({
    likeCount,
    
    // Works like before
    badge() {
      return this.published && this.likeCount > 100 ? 'highlight' : null;
    },
  })),

  withComments: trait((quantity = 10) => ({
    afterCreate(post, server) {
      server.createList('comment', quantity, { post });
    },
  })),
});

// usage example
server.create('post', {title: 'blah blah'}, post => // second argument `i` omitted
  post.asDraft();
  post.withLikes(42);
  post.withComments(3);
);

// old syntax still works, thought arguments would be undefined if client doesn't set a default parameter in the factory
server.create('post', 'asDraft', 'withComments', {title: 'blah blah'});

// chained traits
server.create('post', {title: 'blah blah'}, post => // second argument `i` omitted
  post.asDraft()
	.withLikes(42)
	.withComments(3),
);

// single line
server.create('post', {title: 'blah blah'}, p => p.asDraft().withLikes(42).withComments(3));

// 1
// seems dumb
test('it works', function() {
  server.create('post', ['withComments', { count: 3 }], 'published');

  await visit('/');
  // ...
});

// 2
// seems dumb
test('it works', function() {
  server.create('post', { trait: 'withComments', args: { count: 3 }}, 'published');

  await visit('/');
  // ...
});
  
// 3
// little verbose but closer? I do feel like we need a function or chaining somewhere
test('it works', function() {
  server.create('post', post => {
    post.withComments(3).published();
  });
  
  await visit('/');
  // ...
});

// 4
// this wouldn't really work because server.create('post') returns a model not a factory
test('it works', function() {
  server.create('post').withComments(3).published();
  
  await visit('/');
  // ...
});

// 5
// could do something like this, new function that allows chaining and finish
// with a .value(). Kinda always hated that though.
test('it works', function() {
  server.createWithTraits('post').withComments(3).published().value();
  
  await visit('/');
  // ...
});


// 6
// Could go to the FactoryBot transient attrs approach: https://github.com/thoughtbot/factory_bot/blob/master/GETTING_STARTED.md#transient-attributes
// Kinda crappy thing here is you dont know by looking a this that the
// commentsCount arg is for the withComments trait.
test('it works', function() {
  server.create('post', 'published', 'withComments', { commentsCount: 3 });
  
  await visit('/');
  // ...
});

published(withComments(server.create('post'), 3));

// Perhaps the users that want args for traits would be willing to give up 
// some of the readability that the current synthax gives us?
const traits = [
  new Trait('withComments', { count: 3 }),
  new Trait('withAuthor', { age: 29 }),
];

server.create('post', traits, { title: 'Hello Traits' });

// Major con (at least to me), really hard to read when you try to "one-line" it, but when you split it up, I kinda like it.
server.create('post', [
  new Trait('withComments', { count: 3 }),
  new Trait('withAuthor', { age: 29 }),
], { title: 'Hello Traits'});

// My other thought is that as a user, I'd want to keep this syntax as it's highly declarative and readable (when we don't need the args).
server.create('post', 'withComments', 'withAuthor', { title: 'Hello Traits' });

server.create('post',
  'withComments',                          // same as ever
  (t) => t.withAuthor({name: 'Jane Doe'}), // if function, it gets a traits hash
  {title: 'Functions as Arguments'},       // object merges into "post"
  (t) => [t.liked(3), t.withCoAuthor()]    // optionally return an array of traits
)

server.create('post', {title: 'Functions as Arguments'}, (t) => [
  t.withComments(),
  t.withAuthor({name: 'Jane Doe'}),
  t.liked(3),
  t.withCoAuthor(),
])

// the function could actually get an object containing a traits hash instead
server.create('post', ({trait, futureMirageIdea}) => [
  trait.withComments({count: 3}),
  trait.withAuthor(),
  futureMirageIdea(true),
])

server.createList('post', 3, ({trait}, i) => [
  trait.withAuthor({name: ['Jack', 'Jill', 'Jane'][i]}),
  trait.withComments({count: i * 3}),
])

this.get('/users', (schema, request) => {
})

this.get('/users', ({ request }) => {
})

server.create('post', {title: 'blah blah'}, traits => // second argument `i` omitted
  traits.asDraft();
  traits.withLikes(42);
  traits.withComments(3);
);

server.create('post', post =>
  post.withComments(3);
);

server.create('post', (post, i) =>
  post.withComments(i * 2);
);

// alternative
server.create('post', ({ withComments }) =>
  withComments(2);
);

server.create('post', ({ withComments, i }) =>
  withComments(i * 2);
);

// alternative 2
server.create('post', ({ traits, i }) =>
  traits.withComments(i * 2);
);

server.create('post', { title: 'blah blah' }, post =>
  post.asDraft();
  post.withLikes(42);
  post.withComments(3);
);

withLikes: trait((likeCount) => ({
  likeCount,
  
  // Works like before
  badge() {
    return this.published && this.likeCount > 100 ? 'highlight' : null;
  },
})),

withLikes: trait((likeCount) => {
  let retweetCount = likeCount / 5

  return {
    likeCount,
    retweetCount,
    
    badge() {
      return this.published && this.likeCount > 100 ? 'highlight' : null;
    }
  }
})

withLikes: trait((likeCount) => {
  let retweetCount = likeCount / 5

  this.model.likeCount = likeCount
  this.model.retweetCount = likeCount
  this.model.badge = this.published && this.likeCount > 100 ? 'highlight' : null;
})

withLikes: trait((likeCount) => {
  let retweetCount = likeCount / 5

  this.model.update({
    likeCount: likeCount,
    retweetCount: likeCount,
    badge: this.published && this.likeCount > 100 ? 'highlight' : null;
  })
})

// 0
withLikes: trait((likeCount) => {
  let retweetCount = likeCount / 5

  this.model.update({
    likeCount: likeCount,
    retweetCount: likeCount,
    badge: this.model.published && likeCount > 100 ? 'highlight' : null;
  })
})

// 1
withLikes: trait(function(likeCount) {
  this.model.update({
    likeCount,
    retweetCount: likeCount / 5,
    badge: this.model.published && likeCount > 100 ? 'highlight' : null;
  });
  // this.server
})

// 2
withLikes: trait(({model /*, server */}) => (likeCount) => {
  model.update({
    likeCount,
    retweetCount: likeCount / 5,
    badge: model.published && likeCount > 100 ? 'highlight' : null;
  });
})

export default Factory.extend({
  title: 'Lorem ipsum',
  published: true,

  // using function keyword, but subject to fat arrow pitfall
  withLikes: trait(function(likeCount) {
    this.model.update({
      likeCount,
      retweetCount: likeCount / 5,
      badge: model.published && likeCount > 100 ? 'highlight' : null;
    });
  }),

  // injecting model as first arg
  withLikes: trait((model, [ likeCount ]) {
    model.update({
      likeCount,
      retweetCount: likeCount / 5,
      badge: model.published && likeCount > 100 ? 'highlight' : null;
    });
  }),

  // using traits key
  traits: {
    withLikes(likeCount) {
      this.model.update({
        likeCount,
        retweetCount: likeCount / 5,
        badge: model.published && likeCount > 100 ? 'highlight' : null;
      });
    }
  },

  // ...but even with traits key, you can run into fat arrow pitfall
  traits: {
    withLikes: likeCount => {
      this.model.update({ // ❌ won't work, this context is wrong
        likeCount,
        retweetCount: likeCount / 5,
        badge: model.published && likeCount > 100 ? 'highlight' : null;
      });
    }
  }

});

export default Factory.extend({
  title: 'Lorem ipsum',
  published: true,

  traits: {
    withLikes(likeCount) {
      this.model.update({
        likeCount,
        retweetCount: likeCount / 5,
        badge: model.published && likeCount > 100 ? 'highlight' : null;
      });
    }
  }
});