@osdk/maker 0.12.0-beta.19 → 0.12.0-beta.20

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @osdk/maker
 
+## 0.12.0-beta.20
+
+### Minor Changes
+
+- 45ed433: Target objects are configurable and default parameter ordering is better in OAC actions
+
 ## 0.12.0-beta.19
 
 ### Patch Changes

package/build/browser/api/defineAction.js

@@ -19,7 +19,7 @@ import invariant from "tiny-invariant";
 import { convertToDisplayName, getAllInterfaceProperties } from "./defineObject.js";
 import { namespace, ontologyDefinition, updateOntology } from "./defineOntology.js";
 import { convertConditionDefinition, convertMappingValue } from "./ontologyUtils.js";
-import { OntologyEntityTypeEnum } from "./types.js";
+import { CREATE_OR_MODIFY_OBJECT_PARAMETER, MODIFY_OBJECT_PARAMETER, OntologyEntityTypeEnum } from "./types.js";
 export function defineCreateInterfaceObjectAction(interfaceType, objectType, validation) {
   const allProperties = Object.entries(getAllInterfaceProperties(interfaceType)).filter(([_, prop]) => !isStruct(prop.sharedPropertyType.type));
   if (allProperties.length !== Object.entries(getAllInterfaceProperties(interfaceType)).length) {
@@ -127,6 +127,7 @@ export function defineCreateObjectAction(def) {
         structFieldValues: {}
       }
     }],
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, parameters),
     ...(def.actionLevelValidation ? {
       validation: [convertValidationRule(def.actionLevelValidation)]
     } : {}),
@@ -141,9 +142,6 @@ export function defineCreateObjectAction(def) {
     }),
     ...(def.sections && {
       sections: Object.fromEntries(def.sections.map(section => [section.id, section]))
-    }),
-    ...(def.parameterOrdering && {
-      parameterOrdering: def.parameterOrdering
     })
   });
 }
@@ -220,18 +218,22 @@ export function defineModifyObjectAction(def) {
   const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter(id => !Object.keys(def.nonParameterMappings ?? {}).includes(id) && !def.excludedProperties?.includes(id) && !isStruct(def.objectType.properties?.[id].type) && id !== def.objectType.primaryKeyPropertyApiName);
   const parameterNames = new Set(propertyParameters);
   Object.keys(def.parameterConfiguration ?? {}).forEach(param => parameterNames.add(param));
+  parameterNames.add(MODIFY_OBJECT_PARAMETER);
   if (def.parameterOrdering) {
+    if (!def.parameterOrdering.includes(MODIFY_OBJECT_PARAMETER)) {
+      def.parameterOrdering = [MODIFY_OBJECT_PARAMETER, ...def.parameterOrdering];
+    }
     const sortedOrdering = [...def.parameterOrdering].sort();
     const sortedParameterNames = [...parameterNames].sort();
     !(sortedOrdering.length === sortedParameterNames.length && sortedOrdering.every((name, index) => name === sortedParameterNames[index])) ? process.env.NODE_ENV !== "production" ? invariant(false, `Action parameter ordering for ${def.objectType.apiName} does not match non-excluded properties`) : invariant(false) : void 0;
   }
   const parameters = createParameters(def, parameterNames, false);
   parameters.forEach(p => {
-    if (p.defaultValue === undefined) {
+    if (p.id !== MODIFY_OBJECT_PARAMETER && p.defaultValue === undefined) {
       p.defaultValue = {
         type: "objectParameterPropertyValue",
         objectParameterPropertyValue: {
-          parameterId: "objectToModifyParameter",
+          parameterId: MODIFY_OBJECT_PARAMETER,
           propertyTypeId: p.id
         }
       };
@@ -241,27 +243,12 @@ export function defineModifyObjectAction(def) {
   return defineAction({
     apiName: def.apiName ?? `modify-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`,
     displayName: def.displayName ?? `Modify ${def.objectType.displayName}`,
-    parameters: [{
-      id: "objectToModifyParameter",
-      displayName: "Modify object",
-      type: {
-        type: "objectReference",
-        objectReference: {
-          objectTypeId: def.objectType.apiName
-        }
-      },
-      validation: {
-        allowedValues: {
-          type: "objectQuery"
-        },
-        required: true
-      }
-    }, ...parameters],
+    parameters: parameters,
     status: def.status ?? "active",
     rules: [{
       type: "modifyObjectRule",
       modifyObjectRule: {
-        objectToModify: "objectToModifyParameter",
+        objectToModify: MODIFY_OBJECT_PARAMETER,
         propertyValues: {
           ...Object.fromEntries(propertyParameters.map(p => [p, {
             type: "parameterId",
@@ -278,6 +265,7 @@ export function defineModifyObjectAction(def) {
       affectedLinkTypes: [],
       typeGroups: []
     },
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, parameters, MODIFY_OBJECT_PARAMETER),
     ...(def.actionLevelValidation ? {
       validation: [convertValidationRule(def.actionLevelValidation)]
     } : {}),
@@ -292,9 +280,6 @@ export function defineModifyObjectAction(def) {
     }),
     ...(def.sections && {
       sections: Object.fromEntries(def.sections.map(section => [section.id, section]))
-    }),
-    ...(def.parameterOrdering && {
-      parameterOrdering: def.parameterOrdering
     })
   });
 }
@@ -341,18 +326,22 @@ export function defineCreateOrModifyObjectAction(def) {
   const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter(id => !def.excludedProperties?.includes(id) && !isStruct(def.objectType.properties?.[id].type) && id !== def.objectType.primaryKeyPropertyApiName);
   const parameterNames = new Set(propertyParameters);
   Object.keys(def.parameterConfiguration ?? {}).forEach(param => parameterNames.add(param));
+  parameterNames.add(CREATE_OR_MODIFY_OBJECT_PARAMETER);
   if (def.parameterOrdering) {
+    if (!def.parameterOrdering.includes(CREATE_OR_MODIFY_OBJECT_PARAMETER)) {
+      def.parameterOrdering = [CREATE_OR_MODIFY_OBJECT_PARAMETER, ...def.parameterOrdering];
+    }
     const sortedOrdering = [...def.parameterOrdering].sort();
     const sortedParameterNames = [...parameterNames].sort();
     !(sortedOrdering.length === sortedParameterNames.length && sortedOrdering.every((name, index) => name === sortedParameterNames[index])) ? process.env.NODE_ENV !== "production" ? invariant(false, `Action parameter ordering for ${def.objectType.apiName} does not match non-excluded properties`) : invariant(false) : void 0;
   }
   const parameters = createParameters(def, parameterNames, false);
   parameters.forEach(p => {
-    if (p.defaultValue === undefined) {
+    if (p.id !== CREATE_OR_MODIFY_OBJECT_PARAMETER && p.defaultValue === undefined) {
       p.defaultValue = {
         type: "objectParameterPropertyValue",
         objectParameterPropertyValue: {
-          parameterId: "objectToCreateOrModifyParameter",
+          parameterId: CREATE_OR_MODIFY_OBJECT_PARAMETER,
           propertyTypeId: p.id
         }
       };
@@ -362,34 +351,12 @@ export function defineCreateOrModifyObjectAction(def) {
   return defineAction({
     apiName: def.apiName ?? `create-or-modify-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`,
     displayName: def.displayName ?? `Create or Modify ${def.objectType.displayName}`,
-    parameters: [{
-      id: "objectToCreateOrModifyParameter",
-      displayName: "Create or modify object",
-      type: {
-        type: "objectReference",
-        objectReference: {
-          objectTypeId: def.objectType.apiName,
-          maybeCreateObjectOption: !def.primaryKeyOption || def.primaryKeyOption === "autoGenerated" ? {
-            type: "autoGenerated",
-            autoGenerated: {}
-          } : {
-            type: "userInput",
-            userInput: {}
-          }
-        }
-      },
-      validation: {
-        allowedValues: {
-          type: "objectQuery"
-        },
-        required: true
-      }
-    }, ...parameters],
+    parameters: parameters,
     status: def.status ?? "active",
     rules: [{
       type: "addOrModifyObjectRuleV2",
       addOrModifyObjectRuleV2: {
-        objectToModify: "objectToCreateOrModifyParameter",
+        objectToModify: CREATE_OR_MODIFY_OBJECT_PARAMETER,
         propertyValues: {
           ...Object.fromEntries(propertyParameters.map(p => [p, {
             type: "parameterId",
@@ -406,6 +373,7 @@ export function defineCreateOrModifyObjectAction(def) {
       affectedLinkTypes: [],
       typeGroups: []
     },
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, parameters, CREATE_OR_MODIFY_OBJECT_PARAMETER),
     ...(def.actionLevelValidation ? {
       validation: [convertValidationRule(def.actionLevelValidation)]
     } : {}),
@@ -420,9 +388,6 @@ export function defineCreateOrModifyObjectAction(def) {
     }),
     ...(def.sections && {
       sections: Object.fromEntries(def.sections.map(section => [section.id, section]))
-    }),
-    ...(def.parameterOrdering && {
-      parameterOrdering: def.parameterOrdering
     })
   });
 }
@@ -460,19 +425,70 @@ export function defineAction(actionDef) {
     },
     __type: OntologyEntityTypeEnum.ACTION_TYPE
   };
-  validateActionValidation(fullAction);
+  validateActionConfiguration(fullAction);
   updateOntology(fullAction);
   return fullAction;
 }
 function createParameters(def, parameterSet, defaultRequired) {
-  const parameterNames = Array.from(parameterSet);
+  const targetParam = [];
   // prefix objectReference parameters with the namespace
-  parameterNames.forEach(name => {
+  parameterSet.forEach(name => {
     if (typeof def.parameterConfiguration?.[name]?.customParameterType === "object" && def.parameterConfiguration?.[name]?.customParameterType.type === "objectReference") {
       def.parameterConfiguration[name].customParameterType.objectReference.objectTypeId = sanitize(def.parameterConfiguration[name].customParameterType.objectReference.objectTypeId);
     }
+    if (name === MODIFY_OBJECT_PARAMETER) {
+      targetParam.push({
+        id: MODIFY_OBJECT_PARAMETER,
+        displayName: def.parameterConfiguration?.[name]?.displayName ?? "Modify object",
+        type: {
+          type: "objectReference",
+          objectReference: {
+            objectTypeId: def.objectType.apiName
+          }
+        },
+        validation: {
+          ...def.parameterConfiguration?.[name],
+          allowedValues: {
+            type: "objectQuery"
+          },
+          required: def.parameterConfiguration?.[name]?.required ?? true
+        },
+        defaultValue: def.parameterConfiguration?.[name]?.defaultValue,
+        description: def.parameterConfiguration?.[name]?.description
+      });
+      parameterSet.delete(MODIFY_OBJECT_PARAMETER);
+    }
+    if (name === CREATE_OR_MODIFY_OBJECT_PARAMETER) {
+      targetParam.push({
+        id: CREATE_OR_MODIFY_OBJECT_PARAMETER,
+        displayName: def.parameterConfiguration?.[name]?.displayName ?? "Create or modify object",
+        type: {
+          type: "objectReference",
+          objectReference: {
+            objectTypeId: def.objectType.apiName,
+            maybeCreateObjectOption: !def.primaryKeyOption || def.primaryKeyOption === "autoGenerated" ? {
+              type: "autoGenerated",
+              autoGenerated: {}
+            } : {
+              type: "userInput",
+              userInput: {}
+            }
+          }
+        },
+        validation: {
+          ...def.parameterConfiguration?.[name],
+          allowedValues: {
+            type: "objectQuery"
+          },
+          required: def.parameterConfiguration?.[name]?.required ?? true
+        },
+        defaultValue: def.parameterConfiguration?.[name]?.defaultValue,
+        description: def.parameterConfiguration?.[name]?.description
+      });
+      parameterSet.delete(CREATE_OR_MODIFY_OBJECT_PARAMETER);
+    }
   });
-  return Array.from(parameterNames).map(id => ({
+  return [...targetParam, ...Array.from(parameterSet).map(id => ({
     id,
     displayName: def.parameterConfiguration?.[id]?.displayName ?? def.objectType.properties?.[id]?.displayName ?? convertToDisplayName(id),
     type: def.parameterConfiguration?.[id]?.customParameterType ?? extractActionParameterType(def.objectType.properties?.[id]),
@@ -490,7 +506,7 @@ function createParameters(def, parameterSet, defaultRequired) {
     },
     defaultValue: def.parameterConfiguration?.[id]?.defaultValue,
     description: def.parameterConfiguration?.[id]?.description
-  }));
+  }))];
 }
 function referencedParameterIds(actionDef) {
   const parameterIds = new Set();
@@ -778,7 +794,7 @@ function convertValidationRule(actionValidation) {
     }
   };
 }
-function validateActionValidation(action) {
+function validateActionConfiguration(action) {
   const seenParameterIds = new Set();
   const parameterMap = action.parameters?.reduce((acc, param) => {
     acc[param.id] = param;
@@ -787,15 +803,13 @@ function validateActionValidation(action) {
   const orderedParameters = action.parameterOrdering?.map(id => parameterMap[id]) ?? action.parameters;
   orderedParameters?.forEach(param => {
     param.validation.conditionalOverrides?.forEach(override => {
-      validateActionCondition(override.condition, param.id, seenParameterIds, action.parameters);
+      validateParameterCondition(override.condition, param.id, seenParameterIds, action.parameters);
     });
-    if (param.defaultValue?.type === "staticValue") {
-      !(param.defaultValue.staticValue.type === param.type) ? process.env.NODE_ENV !== "production" ? invariant(false, `Default static value for parameter ${param.id} does not match type`) : invariant(false) : void 0;
-    }
+    validateParameterPrefill(param.id, seenParameterIds, action.parameters, param.defaultValue);
     seenParameterIds.add(param.id);
   });
 }
-function validateActionCondition(condition, currentParameterId, seenParameterIds, parameters) {
+function validateParameterCondition(condition, currentParameterId, seenParameterIds, parameters) {
   switch (condition.type) {
     case "parameter":
       const overrideParamId = condition.parameterId;
@@ -806,12 +820,12 @@ function validateActionCondition(condition, currentParameterId, seenParameterIds
     case "and":
       // this will not catch the niche edge case where users use the full syntax for unions
       if ("conditions" in condition) {
-        condition.conditions.forEach(c => validateActionCondition(c, currentParameterId, seenParameterIds, parameters));
+        condition.conditions.forEach(c => validateParameterCondition(c, currentParameterId, seenParameterIds, parameters));
       }
       break;
     case "or":
       if ("conditions" in condition) {
-        condition.conditions.forEach(c => validateActionCondition(c, currentParameterId, seenParameterIds, parameters));
+        condition.conditions.forEach(c => validateParameterCondition(c, currentParameterId, seenParameterIds, parameters));
       }
       break;
     case "comparison":
@@ -826,13 +840,40 @@ function validateActionCondition(condition, currentParameterId, seenParameterIds
       throw new Error(`Unknown condition type on parameter ${currentParameterId}`);
   }
 }
+function validateParameterPrefill(currentParameterId, seenParameterIds, parameters, defaultValue) {
+  if (!defaultValue) return;
+  switch (defaultValue.type) {
+    case "objectParameterPropertyValue":
+      !parameters?.some(p => p.id === defaultValue.objectParameterPropertyValue.parameterId) ? process.env.NODE_ENV !== "production" ? invariant(false, `Default value for parameter ${currentParameterId} is referencing unknown parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant(false) : void 0;
+      !seenParameterIds.has(defaultValue.objectParameterPropertyValue.parameterId) ? process.env.NODE_ENV !== "production" ? invariant(false, `Default value for parameter ${currentParameterId} is referencing later parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant(false) : void 0;
+      break;
+    case "staticValue":
+      !(defaultValue.staticValue.type === parameters?.find(p => p.id === currentParameterId)?.type) ? process.env.NODE_ENV !== "production" ? invariant(false, `Default static value for parameter ${currentParameterId} does not match type`) : invariant(false) : void 0;
+      break;
+    case "staticObject":
+    case "interfaceParameterPropertyValue":
+    case "objectQueryPrefill":
+    case "objectQueryPropertyValue":
+    case "objectSetRidPrefill":
+    case "redacted":
+      break;
+    default:
+      throw new Error(`Unknown default value type for parameter ${currentParameterId}`);
+  }
+}
 function validateActionParameters(def) {
   // validates that parameters either exist as object properties or have a type defined
   [...Object.keys(def.parameterConfiguration ?? {})].forEach(id => {
-    !(def.objectType.properties?.[id] !== undefined || def.parameterConfiguration?.[id].customParameterType !== undefined) ? process.env.NODE_ENV !== "production" ? invariant(false, `Parameter ${id} does not exist as a property on ${def.objectType.apiName} and its type is not explicitly defined`) : invariant(false) : void 0;
+    !(def.objectType.properties?.[id] !== undefined || def.parameterConfiguration?.[id].customParameterType !== undefined || id === MODIFY_OBJECT_PARAMETER || id === CREATE_OR_MODIFY_OBJECT_PARAMETER) ? process.env.NODE_ENV !== "production" ? invariant(false, `Parameter ${id} does not exist as a property on ${def.objectType.apiName} and its type is not explicitly defined`) : invariant(false) : void 0;
   });
   [...Object.keys(def.nonParameterMappings ?? {}), ...(def.excludedProperties ?? [])].forEach(id => {
     !(def.objectType.properties?.[id] !== undefined) ? process.env.NODE_ENV !== "production" ? invariant(false, `Property ${id} does not exist as a property on ${def.objectType.apiName}`) : invariant(false) : void 0;
   });
 }
+
+// Parameters with configurations will be ordered first in the order they were defined
+// followed by the rest of the parameters in the order they were defined on the object type
+function createDefaultParameterOrdering(def, parameters, priorityId) {
+  return [...(priorityId ? [priorityId] : []), ...Object.keys(def.parameterConfiguration ?? {}), ...Object.keys(def.objectType.properties ?? {}).filter(id => !def.parameterConfiguration?.[id] && parameters.some(p => p.id === id))];
+}
 //# sourceMappingURL=defineAction.js.map