Array or Collection?

[mfreeman-xtivia]

Is is it possible to execute json-fx against an array or collection object, almost along the lines of a map() function where the template is executed against each item in the array/collection?

[rweads0520]

Hi Mike, you can do this currently using a function definition, the built-in map function, and the object value promotion syntax.

const JsonFx = require('@mindsung/json-fx').JsonFx;

const template = {
  "@mapFn($item)": {
    "upper": "$item:toUpperCase",
    "lower": "$item:toLowerCase"
  },
  "()": "$?:map(@mapFn)"
};
const data = ["Hello", "World!"];
const fx = new JsonFx().compile(template);
const result = fx.evaluate({ name: "$", value: data });
console.log(result);
// Output:
//
// [
//   { upper: 'HELLO', lower: 'hello' },
//   { upper: 'WORLD!', lower: 'world!' }
// ]

[mfreeman-xtivia]

So I get the function definition, but am a little perplexed by this:
"()": "$?:map(@mapFn)"

What is the effect of that?

[mfreeman-xtivia]

And i guess the larger question i am struggling with is how would i define a template to serve as a base (say with a bunch of pre-defined function defs), and then use a unique template "chained" from that for each array of data being processed.

Imagine a scenario where i am building a custom dashboard with data being returned as JSON arrays for each chart and i need to define a data transform for each chart, where the transforms can use a base of pre-defined functions

[rweads0520]

You can see the docs for this here: https://www.npmjs.com/package/@mindsung/json-fx#object-value-promotion

Essentially, whatever expression is assigned to the "()" property of the template object (and these can be at the root level, or nested anywhere within any object in the template), will be the evaluated result of the entire object that contains it. So the following are equivalent:

const template = "$:toLowerCase + $:toUpperCase";

const template = {
  "$a": "$:toLowerCase",
  "$b": "$:toUpperCase",
  "@concatStrings($s1, $s2)": "$s1 + $s2",
  "()": "@concatStrings($a, $b)"
};

The "()" syntax just allows you to write a more complex, object-based expression (as opposed to a simple string expression) that outputs a single value. The benefit of using it is that then your expression can define variables and custom functions.

[rweads0520]

So I think the scenario you're describing would look something like below. I've checked this into the repo at /examples/colleciton.js.

const JsonFx = require('@mindsung/json-fx').JsonFx;
const fs = require('fs');

const compiledTemplate = new JsonFx().compile({
  "@mapFn($)": {
    upperLowerChart: JSON.parse(fs.readFileSync('./templates/upper-lower.json')),
    joinStringsChart: JSON.parse(fs.readFileSync('./templates/join-strings.json'))
  },
  "()": "$data?:map(@mapFn)"
});

const data = JSON.parse(fs.readFileSync('./data/words-and-letters.json'));

const chartResults = compiledTemplate.evaluate({ name: "$data", value: data });

console.log(chartResults);

// Output:
//
// [
//   {
//     upperLowerChart: { upper: 'HELLO', lower: 'hello' },
//     joinStringsChart: 'a,b,c'
//   },
//   {
//     upperLowerChart: { upper: 'WORLD!', lower: 'world!' },
//     joinStringsChart: 'd,e,f'
//   }
// ]

Where templates/upper-lower.json:

{
  "upper": "$.someWord:toUpperCase",
  "lower": "$.someWord:toLowerCase"
}

And templates/join-strings.json:

"$.someLetters:join(',')"

And data/words-and-letters.json:

[
  {
    "someWord": "Hello",
    "someLetters": ["a", "b", "c"]
  },
  {
    "someWord": "World!",
    "someLetters": ["d", "e", "f"]
  }
]