Support anonymous entities

[raingerber]

This feature introduces anonymous entities, which are just entities defined without names. Entities that do have names are referred to as declared entities.

API

DataPoint will expose a factory function for each registered entity type:

const dataPoint = require('data-point')

const factories = dataPoint.entityFactories

// {
//   entry: [Function: create],
//   request: [Function: create],
//   hash: [Function: create],
//   ...
// }

const requestEntity = factories.request({
  url: 'https://api.github.com/orgs/nodejs'
})

dataPoint.transform(requestEntity)

Example

This example shows the same transform with declared entities and anonymous entities:

declared:

dataPoint.addEntities({
  'request:getOrgInfo': {
    url: 'https://api.github.com/orgs/nodejs'
  },
  'hash:OrgInfo': {
    mapKeys: {
      reposUrl: '$repos_url',
      eventsUrl: '$events_url'
    }
  }
})

dataPoint.transform('request:getOrgInfo | hash:OrgInfo')

anonymous:

const { request, hash } = dataPoint.entityFactories

dataPoint.transform([
  request({
    url: 'https://api.github.com/orgs/nodejs'
  }),

  hash({
    mapKeys: {
      reposUrl: '$repos_url',
      eventsUrl: '$events_url'
    }
  })
])

These are main benefits I see from anonymous entities:

• No pressure to think of good names for everything 😄
• Currently, entities can reference any other entity, but anonymous entities are not declared in the "global" scope, so there's no question about where they're being used
• More readable, because anonymous entities keep more code in the place where it's being used
• On the other hand, it's easier to share entities between files. Example:

// data-hash.js

module.exports = hash({
  mapKeys: {
    reposUrl: '$repos_url',
    eventsUrl: '$events_url'
  }
}) 

// main.js

const dataHash = require('./data-hash')

dataPoint.transform([
  request({
    url: 'https://api.github.com/orgs/nodejs'
  }),
  dataHash
])

Any thoughts?

[paulmolluzzo]

This is a fantastic idea!

Sorry if this is obvious, but what would happen if an anonymous entity tried to refer to a declared entity?

Here's a rough example of the question:

// data-hash.js

module.exports = hash({
  value:  'request:getOrgInfo', // can refer to declared entity?
  mapKeys: {
    reposUrl: '$repos_url',
    eventsUrl: '$events_url'
  }
}) 

// main.js

const dataHash = require('./data-hash')

dataPoint.addEntities({
  'request:getOrgInfo': {
    url: 'https://api.github.com/orgs/nodejs'
  },
  'hash:OrgInfo': dataHash // would this pull the value from the declared entity?
})

[raingerber]

Glad you like the idea! Your example should work out of the gate, because anonymous entities will support all the features that current entities have (and we can already use entities within other entities).

[acatl]

love this idea, my only concern is people abusing this feature and creating nested entities which could potentially end up in a crazy triangle of hell mess :)

I believe the feature adds a lot of value

things to keep in mind:

• do not depend on datapoint instance, should be exposed as a static factory of DataPoint
• think about usage of custom entities
• parse at compile time, so errors happen there and not at run time

[acatl]

superseded by #129