feat: Support objects in expressions

Author: TomasEng

schemas/json/layout/expression.schema.v1.json

@@ -47,6 +47,7 @@
         { "$ref": "#/definitions/strict-boolean" },
         { "$ref": "#/definitions/strict-number" },
         { "$ref": "#/definitions/strict-list" },
+        { "$ref": "#/definitions/strict-object" },
         { "$ref": "#/definitions/func-if" }
       ]
     },
@@ -155,6 +156,17 @@
         { "$ref": "#/definitions/func-list" }
       ]
     },
+    "object": {
+      "title": "Any expression returning an object",
+      "$ref": "#/definitions/strict-object"
+    },
+    "strict-object": {
+      "title": "Any expression returning an object (strict)",
+      "anyOf": [
+        { "$ref": "#/definitions/func-dataModel" },
+        { "$ref": "#/definitions/func-object" }
+      ]
+    },
     "func-if": {
       "title": "If/else conditional expression",
       "description": "This function will evaluate and return the result of either branch. If else is not given, null will be returned instead.",
@@ -702,6 +714,15 @@
       ],
       "additionalItems": { "$ref": "#/definitions/any" }
     },
+    "func-object": {
+      "title": "Create an object",
+      "description": "This function creates a list from its arguments.",
+      "type": "array",
+      "items": [
+        { "const": "object" }
+      ],
+      "additionalItems": { "$ref": "#/definitions/any" }
+    },
     "compare-operator": {
       "title": "Comparison operator",
       "enum": ["equals", "greaterThan", "greaterThanEq", "lessThan", "lessThanEq", "isAfter", "isBefore", "isAfterEq", "isBeforeEq", "isSameDay"]

src/codegen/dataTypes/GenerateExpressionOr.ts

@@ -11,6 +11,7 @@ const toTsMap: { [key in ExprVal]: string } = {
   [ExprVal.String]: 'ExprValToActualOrExpr<ExprVal.String>',
   [ExprVal.Date]: 'ExprValToActualOrExpr<ExprVal.Date>',
   [ExprVal.List]: 'ExprValToActualOrExpr<ExprVal.List>',
+  [ExprVal.Object]: 'ExprValToActualOrExpr<ExprVal.Object>',
 };
 
 const toSchemaMap: { [key in ExprVal]: JSONSchema7 } = {
@@ -20,6 +21,7 @@ const toSchemaMap: { [key in ExprVal]: JSONSchema7 } = {
   [ExprVal.String]: { $ref: 'expression.schema.v1.json#/definitions/string' },
   [ExprVal.Date]: { $ref: 'expression.schema.v1.json#/definitions/string' },
   [ExprVal.List]: { $ref: 'expression.schema.v1.json#/definitions/list' },
+  [ExprVal.Object]: { $ref: 'expression.schema.v1.json#/definitions/object' },
 };
 
 type TypeMap<Val extends ExprVal> = Val extends ExprVal.Boolean

src/features/expressions/expression-functions.ts

@@ -21,6 +21,7 @@ import type {
   ExprFunctionName,
   ExprFunctions,
   ExprValToActual,
+  ValidObject,
   ValidValue,
 } from 'src/features/expressions/types';
 import type { ValidationContext } from 'src/features/expressions/validation';
@@ -326,6 +327,11 @@ export const ExprFunctionDefinitions = {
     returns: ExprVal.List,
     needs: noSources,
   },
+  object: {
+    args: args(rest(ExprVal.Any)),
+    returns: ExprVal.Object,
+    needs: noSources,
+  },
   _experimentalSelectAndMap: {
     args: args(
       required(ExprVal.String),
@@ -803,6 +809,21 @@ export const ExprFunctionImplementations: { [K in ExprFunctionName]: Implementat
   list(...items): ValidValue[] {
     return items;
   },
+  object(...items): ValidObject {
+    if (items.length % 2 === 1) {
+      throw new ExprRuntimeError(this.expr, this.path, 'The object function must have an even number of arguments');
+    }
+    const keys = extractEvenIndexedArguments(items);
+    if (!consistsOfStringsOnly(keys)) {
+      throw new ExprRuntimeError(this.expr, this.path, 'Object keys must be strings');
+    }
+    if (!areStringsUnique(keys)) {
+      throw new ExprRuntimeError(this.expr, this.path, 'Object keys must be unique');
+    }
+    const values = extractOddIndexedArguments(items);
+    const entries = zipArrays<string, ValidValue>(keys, values);
+    return Object.fromEntries(entries);
+  },
   _experimentalSelectAndMap(path, propertyToSelect, prepend, append, appendToLastElement = true) {
     if (path === null || propertyToSelect == null) {
       throw new ExprRuntimeError(this.expr, this.path, `Cannot lookup dataModel null`);
@@ -1064,3 +1085,23 @@ function validateDates(this: EvaluateExpressionParams, a: ExprDate, b: ExprDate)
     throw new ExprRuntimeError(this.expr, this.path, `Can not compare timestamps where only one specify timezone`);
   }
 }
+
+function extractEvenIndexedArguments(args: ValidValue[]): ValidValue[] {
+  return args.filter((_, index) => index % 2 === 0);
+}
+
+function extractOddIndexedArguments(args: ValidValue[]): ValidValue[] {
+  return args.filter((_, index) => index % 2 === 1);
+}
+
+function consistsOfStringsOnly(array: ValidValue[]): array is string[] {
+  return array.every((value) => typeof value === 'string');
+}
+
+function areStringsUnique(strings: string[]): boolean {
+  return strings.length === new Set(strings).size;
+}
+
+function zipArrays<V1, V2>(array1: V1[], array2: V2[]): Array<[V1, V2]> {
+  return array1.map((value, index) => [value, array2[index]]);
+}

src/features/expressions/index.ts

@@ -10,7 +10,7 @@ import {
 } from 'src/features/expressions/errors';
 import { ExprFunctionDefinitions, ExprFunctionImplementations } from 'src/features/expressions/expression-functions';
 import { ExprVal } from 'src/features/expressions/types';
-import { isValidArray } from 'src/features/expressions/validation';
+import { isValidArray, isValidObject } from 'src/features/expressions/validation';
 import { type ExpressionDataSources } from 'src/utils/layout/useExpressionDataSources';
 import type {
   ExprConfig,
@@ -308,7 +308,7 @@ export const ExprTypes: {
   },
   [ExprVal.Any]: {
     nullable: true,
-    accepts: [ExprVal.Boolean, ExprVal.String, ExprVal.Number, ExprVal.Any, ExprVal.List],
+    accepts: [ExprVal.Boolean, ExprVal.String, ExprVal.Number, ExprVal.Any, ExprVal.List, ExprVal.Object],
     impl: (arg) => arg,
   },
   [ExprVal.Date]: {
@@ -337,6 +337,17 @@ export const ExprTypes: {
       }
     },
   },
+  [ExprVal.Object]: {
+    nullable: false,
+    accepts: [ExprVal.Object, ExprVal.Any],
+    impl(arg) {
+      if (isValidObject(arg)) {
+        return arg;
+      } else {
+        throw new UnexpectedType(this.expr, this.path, 'object', arg);
+      }
+    },
+  },
 };
 
 /**

src/features/expressions/shared-tests/functions/dataModel/array-is-null.json

@@ -12,6 +12,7 @@
         "booleanList": [true, false],
         "nullList": [null, null],
         "multidimensionalList": [[[1, 2], [3, 4]], [[5, 6], [7, 8]]],
+        "objectList": [{ "a": 1 }, { "a": 2 }],
         "emptyList": [],
         "differentTypesList": [1, "string", true, null, []]
       }
@@ -43,6 +44,11 @@
       "expression": ["dataModel", "multidimensionalList"],
       "expects": [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
     },
+    {
+      "name": "Object list lookup",
+      "expression": ["dataModel", "objectList"],
+      "expects": [{ "a": 1 }, { "a": 2 }]
+    },
     {
       "name": "Empty list lookup",
       "expression": ["dataModel", "emptyList"],

src/features/expressions/shared-tests/functions/dataModel/lookup-list.json

@@ -0,0 +1,73 @@
+{
+  "name": "Lookup a list value",
+  "dataModels": [
+    {
+      "dataElement": {
+        "id": "00dd7417-5b4e-402a-bb73-007537071f1d",
+        "dataType": "default"
+      },
+      "data": {
+        "simpleCity": {
+          "name": "Oslo",
+          "numberOfInhabitants": 724290,
+          "isCapital": true,
+          "largestVolcano": null
+        },
+        "complexCity": {
+          "name": "Oslo",
+          "trainStations": [
+            {
+              "name": "Oslo sentralstasjon",
+              "numberOfPlatforms": 19,
+              "isUnderground": false,
+              "expressTrains": ["F1", "F4", "F5", "F6"],
+              "connectedBusTerminal": "Oslo bussterminal"
+            },
+            {
+              "name": "Nationaltheatret",
+              "numberOfPlatforms": 4,
+              "isUnderground": true,
+              "expressTrains": ["F5"],
+              "connectedBusTerminal": null
+            }
+          ]
+        }
+      }
+    }
+  ],
+  "testCases": [
+    {
+      "name": "Simple object lookup",
+      "expression": ["dataModel", "simpleCity"],
+      "expects": {
+        "name": "Oslo",
+        "numberOfInhabitants": 724290,
+        "isCapital": true,
+        "largestVolcano": null
+      }
+    },
+    {
+      "name": "Complex object lookup",
+      "expression": ["dataModel", "complexCity"],
+      "expects": {
+        "name": "Oslo",
+        "trainStations": [
+          {
+            "name": "Oslo sentralstasjon",
+            "numberOfPlatforms": 19,
+            "isUnderground": false,
+            "expressTrains": ["F1", "F4", "F5", "F6"],
+            "connectedBusTerminal": "Oslo bussterminal"
+          },
+          {
+            "name": "Nationaltheatret",
+            "numberOfPlatforms": 4,
+            "isUnderground": true,
+            "expressTrains": ["F5"],
+            "connectedBusTerminal": null
+          }
+        ]
+      }
+    }
+  ]
+}

src/features/expressions/shared-tests/functions/dataModel/lookup-object.json

@@ -21,6 +21,11 @@
       "expression": ["list", ["list", 1, 2], ["list", 3, 4]],
       "expects": [[1, 2], [3, 4]]
     },
+    {
+      "name": "Supports objects",
+      "expression": ["list", ["object", "a", 1], ["object", "b", 2]],
+      "expects": [{ "a": 1 }, { "b": 2 }]
+    },
     {
       "name": "Does not evaluate the final expression when the result happens to be a valid expression",
       "expression": ["list", "equals", 1, 1],