@party-stack/foundry-ontology 0.13.0 → 0.14.1

package/lib/meta/convertMetaActionType.test.js

@@ -1,3 +1,4 @@
+import { validate } from "@party-stack/ontology";
 import { Temporal } from "temporal-polyfill";
 import { describe, expect, it } from "vitest";
 import { convertFoundryMetaActionType } from "./convertMetaActionType.js";
@@ -14,24 +15,78 @@ function actionType(parameters) {
         fullLogicRules: [],
     };
 }
-function omsActionMetadata(parameterName, allowedValues, prefill) {
+function structListParameter() {
     return {
-        actionTypeLogic: {
-            validation: {
-                parameterValidations: {
-                    [parameterName]: {
-                        defaultValidation: {
-                            display: {
-                                prefill,
-                            },
-                            validation: {
-                                allowedValues,
+        displayName: "Entries",
+        dataType: {
+            type: "array",
+            subType: {
+                type: "struct",
+                fields: [
+                    {
+                        name: "code",
+                        fieldType: { type: "string" },
+                        required: true,
+                    },
+                    {
+                        name: "enabled",
+                        fieldType: { type: "boolean" },
+                        required: true,
+                    },
+                ],
+            },
+        },
+        required: false,
+        typeClasses: [],
+    };
+}
+function structListField(parameterId, field) {
+    return {
+        type: "structListParameterFieldValue",
+        parameterId,
+        structParameterFieldApiName: field,
+    };
+}
+function structField(parameterId, field) {
+    return {
+        type: "structParameterFieldValue",
+        parameterId,
+        structParameterFieldApiName: field,
+    };
+}
+function omsActionMetadata(parameterName, allowedValues, prefill, resolvedProperty) {
+    return {
+        actionType: {
+            actionTypeLogic: {
+                validation: {
+                    parameterValidations: {
+                        [parameterName]: {
+                            defaultValidation: {
+                                display: {
+                                    prefill,
+                                },
+                                validation: {
+                                    allowedValues,
+                                },
                             },
                         },
                     },
                 },
             },
         },
+        propertyApiNamesByParameter: resolvedProperty
+            ? new Map([
+                [
+                    resolvedProperty.parameterId,
+                    new Map([
+                        [
+                            resolvedProperty.propertyTypeId,
+                            resolvedProperty.propertyApiName,
+                        ],
+                    ]),
+                ],
+            ])
+            : new Map(),
     };
 }
 function omsOneOf(values, allowed = false) {
@@ -73,6 +128,24 @@ describe("convertFoundryMetaActionType parameter validation", () => {
             name: "validatedAction",
         });
     });
+    it("preserves decimal parameters as strings", () => {
+        const result = convertFoundryMetaActionType(actionType({
+            amount: {
+                displayName: "Amount",
+                dataType: {
+                    type: "decimal",
+                    precision: 38,
+                    scale: 18,
+                },
+                required: true,
+                typeClasses: [],
+            },
+        }));
+        expect(result.parameters[0]?.type).toEqual({
+            kind: "string",
+            value: {},
+        });
+    });
     it("converts closed one-of string validation to an enum constraint", () => {
         const result = convertFoundryMetaActionType(actionType({
             status: {
@@ -216,15 +289,272 @@ describe("convertFoundryMetaActionType parameter validation", () => {
                     objectType: "Task",
                     values: [
                         {
-                            property: [
-                                "createdBy",
-                            ],
+                            property: ["createdBy"],
                             value: {
                                 kind: "contextReference",
                                 value: {
-                                    path: [
-                                        "user",
-                                    ],
+                                    name: "user",
+                                },
+                            },
+                        },
+                    ],
+                },
+            },
+        ]);
+    });
+});
+describe("convertFoundryMetaActionType struct assignments", () => {
+    it.each([
+        {
+            name: "create-object",
+            rule: {
+                type: "createObject",
+                objectTypeApiName: "Record",
+                propertyArguments: {},
+                structPropertyArguments: {
+                    entries: {
+                        code: structListField("entries", "code"),
+                        enabled: structListField("entries", "enabled"),
+                    },
+                },
+            },
+            expectedKind: "createObject",
+        },
+        {
+            name: "update-object",
+            rule: {
+                type: "modifyObject",
+                objectToModify: "record",
+                propertyArguments: {},
+                structPropertyArguments: {
+                    entries: {
+                        code: structListField("entries", "code"),
+                        enabled: structListField("entries", "enabled"),
+                    },
+                },
+            },
+            expectedKind: "updateObject",
+        },
+    ])("converts a complete $name list mapping to a map expression", ({ rule, expectedKind }) => {
+        const metadata = actionType({
+            entries: structListParameter(),
+            record: {
+                displayName: "Record",
+                dataType: {
+                    type: "object",
+                    objectTypeApiName: "Record",
+                    objectApiName: "record",
+                },
+                required: true,
+                typeClasses: [],
+            },
+        });
+        metadata.fullLogicRules = [rule];
+        expect(convertFoundryMetaActionType(metadata).logic).toMatchObject([
+            {
+                kind: expectedKind,
+                value: {
+                    values: [
+                        {
+                            property: ["entries"],
+                            value: {
+                                kind: "map",
+                                value: {
+                                    source: {
+                                        kind: "inputReference",
+                                        value: {
+                                            name: "entries",
+                                        },
+                                    },
+                                    binding: "item",
+                                    body: {
+                                        kind: "struct",
+                                        value: {
+                                            fields: [
+                                                {
+                                                    name: "code",
+                                                    value: {
+                                                        kind: "getAt",
+                                                        value: {
+                                                            source: {
+                                                                kind: "localReference",
+                                                                value: {
+                                                                    name: "item",
+                                                                },
+                                                            },
+                                                            path: ["code"],
+                                                        },
+                                                    },
+                                                },
+                                                {
+                                                    name: "enabled",
+                                                    value: {
+                                                        kind: "getAt",
+                                                        value: {
+                                                            source: {
+                                                                kind: "localReference",
+                                                                value: {
+                                                                    name: "item",
+                                                                },
+                                                            },
+                                                            path: ["enabled"],
+                                                        },
+                                                    },
+                                                },
+                                            ],
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+            },
+        ]);
+    });
+    it("preserves nested assignments for an ordinary struct", () => {
+        const metadata = actionType({
+            details: {
+                displayName: "Details",
+                dataType: {
+                    type: "struct",
+                    fields: [
+                        {
+                            name: "code",
+                            fieldType: { type: "string" },
+                            required: true,
+                        },
+                    ],
+                },
+                required: true,
+                typeClasses: [],
+            },
+        });
+        metadata.fullLogicRules = [
+            {
+                type: "createObject",
+                objectTypeApiName: "Record",
+                propertyArguments: {},
+                structPropertyArguments: {
+                    details: {
+                        code: structField("details", "code"),
+                    },
+                },
+            },
+        ];
+        expect(convertFoundryMetaActionType(metadata).logic).toMatchObject([
+            {
+                value: {
+                    values: [
+                        {
+                            property: ["details", "code"],
+                            value: {
+                                kind: "getAt",
+                                value: {
+                                    source: {
+                                        kind: "inputReference",
+                                        value: { name: "details" },
+                                    },
+                                    path: ["code"],
+                                },
+                            },
+                        },
+                    ],
+                },
+            },
+        ]);
+    });
+    it.each([
+        {
+            name: "partial",
+            fields: {
+                code: structListField("entries", "code"),
+            },
+            expectedFields: [
+                {
+                    name: "code",
+                    value: {
+                        kind: "getAt",
+                        value: {
+                            source: {
+                                kind: "localReference",
+                                value: { name: "item" },
+                            },
+                            path: ["code"],
+                        },
+                    },
+                },
+            ],
+        },
+        {
+            name: "renamed",
+            fields: {
+                renamedCode: structListField("entries", "code"),
+                enabled: structListField("entries", "enabled"),
+            },
+            expectedFields: [
+                {
+                    name: "renamedCode",
+                    value: {
+                        kind: "getAt",
+                        value: {
+                            source: {
+                                kind: "localReference",
+                                value: { name: "item" },
+                            },
+                            path: ["code"],
+                        },
+                    },
+                },
+                {
+                    name: "enabled",
+                    value: {
+                        kind: "getAt",
+                        value: {
+                            source: {
+                                kind: "localReference",
+                                value: { name: "item" },
+                            },
+                            path: ["enabled"],
+                        },
+                    },
+                },
+            ],
+        },
+    ])("converts a $name list mapping to a map expression", ({ fields, expectedFields }) => {
+        const metadata = actionType({
+            entries: structListParameter(),
+        });
+        metadata.fullLogicRules = [
+            {
+                type: "createObject",
+                objectTypeApiName: "Record",
+                propertyArguments: {},
+                structPropertyArguments: { entries: fields },
+            },
+        ];
+        expect(convertFoundryMetaActionType(metadata).logic).toMatchObject([
+            {
+                value: {
+                    values: [
+                        {
+                            property: ["entries"],
+                            value: {
+                                kind: "map",
+                                value: {
+                                    source: {
+                                        kind: "inputReference",
+                                        value: {
+                                            name: "entries",
+                                        },
+                                    },
+                                    binding: "item",
+                                    body: {
+                                        kind: "struct",
+                                        value: {
+                                            fields: expectedFields,
+                                        },
+                                    },
                                 },
                             },
                         },
@@ -233,6 +563,159 @@ describe("convertFoundryMetaActionType parameter validation", () => {
             },
         ]);
     });
+    it("rejects mappings driven by multiple list parameters", () => {
+        const metadata = actionType({
+            entries: structListParameter(),
+            otherEntries: structListParameter(),
+        });
+        metadata.fullLogicRules = [
+            {
+                type: "createObject",
+                objectTypeApiName: "Record",
+                propertyArguments: {},
+                structPropertyArguments: {
+                    entries: {
+                        code: structListField("entries", "code"),
+                        enabled: structListField("otherEntries", "enabled"),
+                    },
+                },
+            },
+        ];
+        expect(() => convertFoundryMetaActionType(metadata)).toThrow('Unsupported Foundry list-of-struct assignment for property "entries": fields are mapped from multiple list parameters');
+    });
+    it("rejects mappings that mix list and non-list struct fields", () => {
+        const metadata = actionType({
+            entries: structListParameter(),
+            details: {
+                displayName: "Details",
+                dataType: {
+                    type: "struct",
+                    fields: [
+                        {
+                            name: "enabled",
+                            fieldType: { type: "boolean" },
+                            required: true,
+                        },
+                    ],
+                },
+                required: true,
+                typeClasses: [],
+            },
+        });
+        metadata.fullLogicRules = [
+            {
+                type: "createObject",
+                objectTypeApiName: "Record",
+                propertyArguments: {},
+                structPropertyArguments: {
+                    entries: {
+                        code: structListField("entries", "code"),
+                        enabled: structField("details", "enabled"),
+                    },
+                },
+            },
+        ];
+        expect(() => convertFoundryMetaActionType(metadata)).toThrow('Unsupported Foundry list-of-struct assignment for property "entries": list fields are mixed with non-list struct field arguments');
+    });
+    it("produces action IR that passes ontology validation", () => {
+        const metadata = actionType({
+            entries: structListParameter(),
+            record: {
+                displayName: "Record",
+                dataType: {
+                    type: "object",
+                    objectTypeApiName: "Record",
+                    objectApiName: "record",
+                },
+                required: true,
+                typeClasses: [],
+            },
+        });
+        metadata.fullLogicRules = [
+            {
+                type: "createObject",
+                objectTypeApiName: "Record",
+                propertyArguments: {},
+                structPropertyArguments: {
+                    entries: {
+                        code: structListField("entries", "code"),
+                        enabled: structListField("entries", "enabled"),
+                    },
+                    summaries: {
+                        identifier: structListField("entries", "code"),
+                    },
+                },
+            },
+            {
+                type: "modifyObject",
+                objectToModify: "record",
+                propertyArguments: {},
+                structPropertyArguments: {
+                    entries: {
+                        code: structListField("entries", "code"),
+                        enabled: structListField("entries", "enabled"),
+                    },
+                },
+            },
+        ];
+        const converted = convertFoundryMetaActionType(metadata);
+        const ontology = {
+            types: [],
+            objectTypes: [
+                {
+                    name: "Record",
+                    displayName: "Record",
+                    pluralDisplayName: "Records",
+                    primaryKey: "id",
+                    properties: [
+                        {
+                            name: "id",
+                            displayName: "ID",
+                            type: { kind: "string", value: {} },
+                        },
+                        {
+                            name: "entries",
+                            displayName: "Entries",
+                            type: converted.parameters[0].type,
+                        },
+                        {
+                            name: "summaries",
+                            displayName: "Summaries",
+                            type: {
+                                kind: "optional",
+                                value: {
+                                    type: {
+                                        kind: "list",
+                                        value: {
+                                            elementType: {
+                                                kind: "struct",
+                                                value: {
+                                                    fields: [
+                                                        {
+                                                            name: "identifier",
+                                                            displayName: "Identifier",
+                                                            type: {
+                                                                kind: "string",
+                                                                value: {},
+                                                            },
+                                                        },
+                                                    ],
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+            linkTypes: [],
+            actionTypes: [converted],
+            queryFunctionTypes: [],
+        };
+        expect(validate(ontology)).toEqual({ kind: "ok" });
+    });
 });
 describe("convertFoundryMetaActionType OMS string constraints", () => {
     it("uses a closed OMS one-of and preserves its prefill", () => {
@@ -273,7 +756,7 @@ describe("convertFoundryMetaActionType OMS string constraints", () => {
         });
     });
     it("preserves open OMS one-of values as optional string suggestions", () => {
-        const result = convertFoundryMetaActionType(actionType({
+        const metadata = actionType({
             country: {
                 displayName: "Country",
                 dataType: { type: "string" },
@@ -290,7 +773,21 @@ describe("convertFoundryMetaActionType OMS string constraints", () => {
                 required: true,
                 typeClasses: [],
             },
-        }), omsActionMetadata("country", omsOneOf([
+        });
+        metadata.fullLogicRules = [
+            {
+                type: "modifyObject",
+                objectToModify: "claim",
+                propertyArguments: {
+                    country: {
+                        type: "parameterId",
+                        parameterId: "country",
+                    },
+                },
+                structPropertyArguments: {},
+            },
+        ];
+        const result = convertFoundryMetaActionType(metadata, omsActionMetadata("country", omsOneOf([
             { label: "United States", value: "US" },
             { label: "Mexico", value: "MX" },
             { label: "Canada", value: "CA" },
@@ -300,6 +797,10 @@ describe("convertFoundryMetaActionType OMS string constraints", () => {
                 parameterId: "claim",
                 propertyTypeId: "country",
             },
+        }, {
+            propertyTypeId: "country",
+            parameterId: "claim",
+            propertyApiName: "country",
         }));
         expect(result.parameters[0]?.type).toEqual({
             kind: "optional",
@@ -326,9 +827,18 @@ describe("convertFoundryMetaActionType OMS string constraints", () => {
             },
         });
         expect(result.parameters[0]?.defaultValue).toEqual({
-            kind: "valueReference",
+            kind: "getAt",
             value: {
-                path: ["claim", "country"],
+                source: {
+                    kind: "objectLookup",
+                    value: {
+                        reference: {
+                            kind: "inputReference",
+                            value: { name: "claim" },
+                        },
+                    },
+                },
+                path: ["country"],
             },
         });
     });
@@ -451,7 +961,7 @@ describe("convertFoundryMetaActionType OMS string constraints", () => {
 });
 describe("convertFoundryMetaActionType OMS defaults", () => {
     it("converts static and object-property prefills to parameter defaults", () => {
-        const result = convertFoundryMetaActionType(actionType({
+        const metadata = actionType({
             assignee: {
                 displayName: "Assignee",
                 dataType: {
@@ -474,31 +984,34 @@ describe("convertFoundryMetaActionType OMS defaults", () => {
                 required: false,
                 typeClasses: [],
             },
-        }), {
-            actionTypeLogic: {
-                validation: {
-                    parameterValidations: {
-                        assigneeName: {
-                            defaultValidation: {
-                                display: {
-                                    prefill: {
-                                        type: "objectParameterPropertyValue",
-                                        objectParameterPropertyValue: {
-                                            parameterId: "assignee",
-                                            propertyTypeId: "name",
+        });
+        const result = convertFoundryMetaActionType(metadata, {
+            actionType: {
+                actionTypeLogic: {
+                    validation: {
+                        parameterValidations: {
+                            assigneeName: {
+                                defaultValidation: {
+                                    display: {
+                                        prefill: {
+                                            type: "objectParameterPropertyValue",
+                                            objectParameterPropertyValue: {
+                                                parameterId: "assignee",
+                                                propertyTypeId: "legacy-display-name-id",
+                                            },
                                         },
                                     },
                                 },
                             },
-                        },
-                        notes: {
-                            defaultValidation: {
-                                display: {
-                                    prefill: {
-                                        type: "staticValue",
-                                        staticValue: {
-                                            type: "string",
-                                            string: "from-foundry",
+                            notes: {
+                                defaultValidation: {
+                                    display: {
+                                        prefill: {
+                                            type: "staticValue",
+                                            staticValue: {
+                                                type: "string",
+                                                string: "from-foundry",
+                                            },
                                         },
                                     },
                                 },
@@ -507,6 +1020,17 @@ describe("convertFoundryMetaActionType OMS defaults", () => {
                     },
                 },
             },
+            propertyApiNamesByParameter: new Map([
+                [
+                    "assignee",
+                    new Map([
+                        [
+                            "legacy-display-name-id",
+                            "displayName",
+                        ],
+                    ]),
+                ],
+            ]),
         });
         expect(result.parameters).toMatchObject([
             {
@@ -515,9 +1039,18 @@ describe("convertFoundryMetaActionType OMS defaults", () => {
             {
                 name: "assigneeName",
                 defaultValue: {
-                    kind: "valueReference",
+                    kind: "getAt",
                     value: {
-                        path: ["assignee", "name"],
+                        source: {
+                            kind: "objectLookup",
+                            value: {
+                                reference: {
+                                    kind: "inputReference",
+                                    value: { name: "assignee" },
+                                },
+                            },
+                        },
+                        path: ["displayName"],
                     },
                 },
             },
@@ -598,15 +1131,19 @@ describe("convertFoundryMetaActionType OMS defaults", () => {
                 typeClasses: [],
             },
         }), {
-            actionTypeLogic: {
-                validation: {
-                    parameterValidations: {
-                        assignee: {
-                            defaultValidation: {
-                                display: {
-                                    prefill: {
-                                        type: "objectQueryPrefill",
-                                        objectQueryPrefill: { objectSet },
+            actionType: {
+                actionTypeLogic: {
+                    validation: {
+                        parameterValidations: {
+                            assignee: {
+                                defaultValidation: {
+                                    display: {
+                                        prefill: {
+                                            type: "objectQueryPrefill",
+                                            objectQueryPrefill: {
+                                                objectSet,
+                                            },
+                                        },
                                     },
                                 },
                             },
@@ -614,6 +1151,7 @@ describe("convertFoundryMetaActionType OMS defaults", () => {
                     },
                 },
             },
+            propertyApiNamesByParameter: new Map(),
         });
         expect(result.parameters[0]?.defaultValue).toBeUndefined();
     });
@@ -635,31 +1173,38 @@ describe("convertFoundryMetaActionType OMS defaults", () => {
                 typeClasses: [],
             },
         }), {
-            actionTypeLogic: {
-                validation: {
-                    parameterValidations: {
-                        dueDate: {
-                            defaultValidation: {
-                                display: {
-                                    prefill: {
-                                        type: "staticValue",
-                                        staticValue: {
-                                            type: "date",
-                                            date: { dateValue: "2026-08-31" },
+            actionType: {
+                actionTypeLogic: {
+                    validation: {
+                        parameterValidations: {
+                            dueDate: {
+                                defaultValidation: {
+                                    display: {
+                                        prefill: {
+                                            type: "staticValue",
+                                            staticValue: {
+                                                type: "date",
+                                                date: {
+                                                    dateValue: "2026-08-31",
+                                                },
+                                            },
                                         },
                                     },
                                 },
                             },
-                        },
-                        tags: {
-                            defaultValidation: {
-                                display: {
-                                    prefill: {
-                                        type: "staticValue",
-                                        staticValue: {
-                                            type: "stringList",
-                                            stringList: {
-                                                strings: ["priority", "customer"],
+                            tags: {
+                                defaultValidation: {
+                                    display: {
+                                        prefill: {
+                                            type: "staticValue",
+                                            staticValue: {
+                                                type: "stringList",
+                                                stringList: {
+                                                    strings: [
+                                                        "priority",
+                                                        "customer",
+                                                    ],
+                                                },
                                             },
                                         },
                                     },
@@ -669,6 +1214,7 @@ describe("convertFoundryMetaActionType OMS defaults", () => {
                     },
                 },
             },
+            propertyApiNamesByParameter: new Map(),
         });
         const dueDateDefault = result.parameters[0]?.defaultValue;
         const tagsDefault = result.parameters[1]?.defaultValue;
@@ -680,10 +1226,7 @@ describe("convertFoundryMetaActionType OMS defaults", () => {
         const date = dueDateDefault.value.value;
         expect(date).toBeInstanceOf(Temporal.PlainDate);
         expect(date.toString()).toBe("2026-08-31");
-        expect(tagsDefault.value.value).toEqual([
-            "priority",
-            "customer",
-        ]);
+        expect(tagsDefault.value.value).toEqual(["priority", "customer"]);
     });
 });
 //# sourceMappingURL=convertMetaActionType.test.js.map