@bizone-ai/json-transform-utils 1.10.0

package/dist/functions/examples/distinct.json

@@ -0,0 +1,142 @@
+[
+    {
+        "name": "primitives with duplicates",
+        "given": {
+            "input": ["a", "b", "b", "c", "b"],
+            "definition": {
+                "$$distinct": "$"
+            }
+        },
+        "expect": {
+            "equal": ["a", "b", "c"]
+        }
+    },
+    {
+        "name": "mixed primitives with duplicates",
+        "given": {
+            "input": ["a", 1, false, "b", "c", "b", 1, false, false],
+            "definition": {
+                "$$distinct": "$"
+            }
+        },
+        "expect": {
+            "equal": ["a", 1, false, "b", "c"]
+        }
+    },
+    {
+        "name": "primitives with nulls",
+        "given": {
+            "input": ["a", "a", null, null, "a", null],
+            "definition": {
+                "$$distinct": "$"
+            }
+        },
+        "expect": {
+            "equal": ["a", null]
+        }
+    },
+    {
+        "name": "objects with duplicates",
+        "given": {
+            "input": [{ "a": 1 }, { "a": 1 }, { "a": 1 }],
+            "definition": {
+                "$$distinct": "$"
+            }
+        },
+        "expect": {
+            "equal": [{ "a": 1 }]
+        }
+    },
+    {
+        "name": "arrays with duplicates",
+        "given": {
+            "input": [["a", 1], ["a", 2], ["a", 1], ["a", 1]],
+            "definition": {
+                "$$distinct": "$"
+            }
+        },
+        "expect": {
+            "equal": [
+                ["a", 1],
+                ["a", 2]
+            ]
+        }
+    },
+    {
+        "name": "objects with duplicates with by",
+        "given": {
+            "input": [{ "a": 1 }, { "a": 1 }, { "a": 1 }],
+            "definition": {
+                "$$distinct": "$",
+                "by": "##current"
+            }
+        },
+        "expect": {
+            "equal": [{ "a": 1 }]
+        }
+    },
+    {
+        "name": "arrays with duplicates with by",
+        "given": {
+            "input": [["a", 1], ["a", 2], ["a", 1], ["a", 1]],
+            "definition": {
+                "$$distinct": "$",
+                "by": "##current"
+            }
+        },
+        "expect": {
+            "equal": [
+                ["a", 1],
+                ["a", 2]
+            ]
+        }
+    },
+    {
+        "name": "withTransformation by a",
+        "given": {
+            "input": [{ "a": 1 }, { "a": 1, "b": 1 }, { "a": 1, "b": 2 }, { "a": 2, "b": 1 }],
+            "definition": {
+                "$$distinct": "$",
+                "by": "##current.a"
+            }
+        },
+        "expect": {
+            "equal": [{ "a": 1 }, { "a": 2, "b": 1 }]
+        }
+    },
+    {
+        "name": "withTransformation by b",
+        "given": {
+            "input": [{ "a": 1 }, { "a": 1, "b": 1 }, { "a": 1, "b": 2 }, { "a": 2, "b": 1 }],
+            "definition": {
+                "$$distinct": "$",
+                "by": "##current.b"
+            }
+        },
+        "expect": {
+            "equal": [{ "a": 1 }, { "a": 1, "b": 1 }, { "a": 1, "b": 2 }]
+        }
+    },
+    {
+        "name": "withTransformation without by and same arguments should stay the same",
+        "given": {
+            "input": [{ "a": 1 }, { "a": 1, "b": 1 }, { "a": 1, "b": 2 }, { "a": 2, "b": 1 }],
+            "definition": {
+                "$$distinct": "$"
+            }
+        },
+        "expect": {
+            "equal": [{ "a": 1 }, { "a": 1, "b": 1 }, { "a": 1, "b": 2 }, { "a": 2, "b": 1 }]
+        }
+    },
+    {
+        "name": "inline by a",
+        "given": {
+            "input": [{ "a": 1 }, { "a": 1, "b": 1 }, { "a": 1, "b": 2 }, { "a": 2, "b": 1 }],
+            "definition": "$$distinct(##current.a):$"
+        },
+        "expect": {
+            "equal": [{ "a": 1 }, { "a": 2, "b": 1 }]
+        }
+    }
+]

package/dist/functions/examples/entries.json

@@ -0,0 +1,88 @@
+[
+    {
+        "name": "inline - object to entries",
+        "given": {
+            "input": {
+                "a": 1,
+                "b": true,
+                "c": "C"
+            },
+            "definition": "$$entries:$"
+        },
+        "expect": {
+            "equal": [
+                ["a", 1],
+                ["b", true],
+                ["c", "C"]
+            ],
+            "ignoreOrder": true
+        }
+    },
+    {
+        "name": "inline - array to entries",
+        "given": {
+            "input": [1, true, "C"],
+            "definition": "$$entries:$"
+        },
+        "expect": {
+            "equal": [
+                [0, 1],
+                [1, true],
+                [2, "C"]
+            ]
+        }
+    },
+    {
+        "name": "object - object to entries",
+        "given": {
+            "input": {
+                "a": 1,
+                "b": true,
+                "c": "C"
+            },
+            "definition": { "$$entries": "$" }
+        },
+        "expect": {
+            "equal": [
+                ["a", 1],
+                ["b", true],
+                ["c", "C"]
+            ],
+            "ignoreOrder": true
+        }
+    },
+    {
+        "name": "object - array to entries",
+        "given": {
+            "input": [1, true, "C"],
+            "definition": { "$$entries": "$" }
+        },
+        "expect": {
+            "equal": [
+                [0, 1],
+                [1, true],
+                [2, "C"]
+            ]
+        }
+    },
+    {
+        "name": "object - explicit",
+        "given": {
+            "input": {
+                "a": 1,
+                "b": true,
+                "c": "C"
+            },
+            "definition": { "$$entries": { "*": "$", "d": 0.5 } }
+        },
+        "expect": {
+            "equal": [
+                ["a", 1],
+                ["b", true],
+                ["c", "C"],
+                ["d", 0.5]
+            ],
+            "ignoreOrder": true
+        }
+    }
+]

package/dist/functions/examples/eval.json

@@ -0,0 +1,72 @@
+[
+    {
+        "name": "inline",
+        "given": {
+            "input": {
+                "a": 42,
+                "b": "$.a"
+            },
+            "definition": "$$eval:$.b"
+        },
+        "expect": {
+            "equal": 42
+        }
+    },
+    {
+        "name": "object - 1",
+        "given": {
+            "input": [
+                {
+                    "value": 4
+                },
+                {
+                    "value": 2
+                },
+                {
+                    "value": 13.45
+                },
+                {}
+            ],
+            "definition": {
+                "$$eval": {
+                    "$$join": [
+                        "\\$",
+                        "$avg:",
+                        "\\$",
+                        "..value"
+                    ]
+                }
+            }
+        },
+        "expect": {
+            "equal": 6.483333333333333
+        }
+    },
+    {
+        "name": "object - 2",
+        "given": {
+            "input": [
+                {
+                    "value": 4
+                },
+                {
+                    "value": 2
+                },
+                {
+                    "value": 13.45
+                },
+                {
+                    "value": null
+                }
+            ],
+            "definition": {
+                "$$eval": {
+                    "$$jsonparse": "{\"$$avg\":\"$\", \"by\":\"##current.value\"}"
+                }
+            }
+        },
+        "expect": {
+            "equal": 4.8625
+        }
+    }
+]

package/dist/functions/examples/every.json

@@ -0,0 +1,96 @@
+[
+    {
+        "name": "inline - true",
+        "given": {
+            "input": [
+                {
+                    "active": true
+                },
+                {
+                    "active": true
+                }
+            ],
+            "definition": "$$every(##current.active):$"
+        },
+        "expect": {
+            "equal": true
+        }
+    },
+    {
+        "name": "inline - false",
+        "given": {
+            "input": [
+                {
+                    "active": false
+                },
+                {
+                    "active": true
+                }
+            ],
+            "definition": "$$every(##current.active):$"
+        },
+        "expect": {
+            "equal": false
+        }
+    },
+    {
+        "name": "object - true",
+        "given": {
+            "input": [
+                {
+                    "active": true
+                },
+                {
+                    "active": true
+                }
+            ],
+            "definition": {
+                "$$every": "$",
+                "by": "##current.active"
+            }
+        },
+        "expect": {
+            "equal": true
+        }
+    },
+    {
+        "name": "object - false",
+        "given": {
+            "input": [
+                {
+                    "active": false
+                },
+                {
+                    "active": true
+                }
+            ],
+            "definition": {
+                "$$every": "$",
+                "by": "##current.active"
+            }
+        },
+        "expect": {
+            "equal": false
+        }
+    },
+    {
+        "name": "object - true - alias all",
+        "given": {
+            "input": [
+                {
+                    "active": true
+                },
+                {
+                    "active": true
+                }
+            ],
+            "definition": {
+                "$$all": "$",
+                "by": "##current.active"
+            }
+        },
+        "expect": {
+            "equal": true
+        }
+    }
+]

package/dist/functions/examples/filter.json

@@ -0,0 +1,51 @@
+[
+    {
+        "name": "truthy values only",
+        "given": {
+            "input": ["a", true, "false", 0, 1, [], [0]],
+            "definition": {
+                "$$filter": "$",
+                "by": "##current"
+            }
+        },
+        "expect": {
+            "equal": ["a", true, "false", 1, [0]]
+        }
+    },
+    {
+        "name": "truthy values only (explicit boolean, non js style)",
+        "given": {
+            "input": ["a", true, "false", 0, 1, [], [0]],
+            "definition": {
+                "$$filter": "$",
+                "by": "$$boolean:##current"
+            }
+        },
+        "expect": {
+            "equal": [true, 1, [0]]
+        }
+    },
+    {
+        "name": "names that starts with a",
+        "given": {
+            "input": [{ "name": "alice" }, { "name": "ann" }, { "name": "bob" }],
+            "definition": {
+                "$$filter": "$",
+                "by": "$$test(^a):##current.name"
+            }
+        },
+        "expect": {
+            "equal": [{ "name": "alice" }, { "name": "ann" }]
+        }
+    },
+    {
+        "name": "inline",
+        "given": {
+            "input": ["a", true, "false", 0, 1, [], [0]],
+            "definition": "$$filter(##current):$"
+        },
+        "expect": {
+            "equal": ["a", true, "false", 1, [0]]
+        }
+    }
+]

package/dist/functions/examples/find.json

@@ -0,0 +1,51 @@
+[
+    {
+        "name": "findTheTruth",
+        "given": {
+            "input": [0, [], "a"],
+            "definition": {
+                "$$find": "$",
+                "by": "##current"
+            }
+        },
+        "expect": {
+            "equal": "a"
+        }
+    },
+    {
+        "name": "findTheTruth explicit boolean",
+        "given": {
+            "input": ["a", "1", "true"],
+            "definition": {
+                "$$find": "$",
+                "by": "$$boolean:##current"
+            }
+        },
+        "expect": {
+            "equal": "true"
+        }
+    },
+    {
+        "name": "nameThatStartsWithB",
+        "given": {
+            "input": [{ "name": "alice" }, { "name": "ann" }, { "name": "Bob" }],
+            "definition": {
+                "$$find": "$",
+                "by": "$$test('(?i)^b'):##current.name"
+            }
+        },
+        "expect": {
+            "equal": { "name": "Bob" }
+        }
+    },
+    {
+        "name": "inline",
+        "given": {
+            "input": [0, [], "a"],
+            "definition": "$$find(##current):$"
+        },
+        "expect": {
+            "equal": "a"
+        }
+    }
+]

package/dist/functions/examples/findindex.json

@@ -0,0 +1,61 @@
+[
+    {
+        "name": "object - found",
+        "given": {
+            "input": [0, [], "a"],
+            "definition": {
+                "$$findindex": "$",
+                "by": "##current"
+            }
+        },
+        "expect": {
+            "equal": 2
+        }
+    },
+    {
+        "name": "object - explicit boolean",
+        "given": {
+            "input": ["a", "1", "true"],
+            "definition": {
+                "$$findindex": "$",
+                "by": "$$boolean:##current"
+            }
+        },
+        "expect": {
+            "equal": 2
+        }
+    },
+    {
+        "name": "object - not found",
+        "given": {
+            "input": ["a", "1", "false"],
+            "definition": {
+                "$$findindex": "$",
+                "by": "$$boolean:##current"
+            }
+        },
+        "expect": {
+            "equal": -1
+        }
+    },
+    {
+        "name": "inline - found",
+        "given": {
+            "input": [0, [], "a"],
+            "definition": "$$findindex(##current):$"
+        },
+        "expect": {
+            "equal": 2
+        }
+    },
+    {
+        "name": "inline - not found",
+        "given": {
+            "input": [0, [], "false"],
+            "definition": "$$findindex('$$boolean:##current'):$"
+        },
+        "expect": {
+            "equal": -1
+        }
+    }
+]

package/dist/functions/examples/flat.json

@@ -0,0 +1,74 @@
+[
+    {
+        "name": "object flat 2 arrays",
+        "given": {
+            "input": [
+                ["a", "b", "c"],
+                ["d", "e", "f"]
+            ],
+            "definition": {
+                "$$flat": ["$[0]", "$[1]"]
+            }
+        },
+        "expect": {
+            "equal": ["a", "b", "c", "d", "e", "f"]
+        }
+    },
+    {
+        "name": "object flat 1 array",
+        "given": {
+            "input": [
+                ["a", "b", "c"],
+                ["d", "e", "f"]
+            ],
+            "definition": {
+                "$$flat": ["$[0]", "$.pointingToNowhere"]
+            }
+        },
+        "expect": {
+            "equal": ["a", "b", "c"]
+        }
+    },
+    {
+        "name": "object flat 2 arrays inline",
+        "given": {
+            "input": [
+                ["a", "b", "c"],
+                ["d", "e", "f"]
+            ],
+            "definition": {
+                "$$flat": [
+                    ["a", "b", "c"],
+                    ["d", "e", "f"]
+                ]
+            }
+        },
+        "expect": {
+            "equal": ["a", "b", "c", "d", "e", "f"]
+        }
+    },
+    {
+        "name": "object flat 1 array inline",
+        "given": {
+            "input": ["a", "b", "c"],
+            "definition": {
+                "$$flat": [["a", "b", "c"], []]
+            }
+        },
+        "expect": {
+            "equal": ["a", "b", "c"]
+        }
+    },
+    {
+        "name": "object flat 1 array with null",
+        "given": {
+            "input": ["a", "b", "c"],
+            "definition": {
+                "$$flat": [["a", "b", "c"], null]
+            }
+        },
+        "expect": {
+            "equal": ["a", "b", "c"]
+        }
+    }
+]