@servicenow/sdk-build-plugins 4.1.1 → 4.3.0

package/dist/flow/plugins/flow-instance-plugin.js

@@ -0,0 +1,930 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowInstancePlugin = void 0;
+exports.normalizeInputValue = normalizeInputValue;
+const sdk_build_core_1 = require("@servicenow/sdk-build-core");
+const now_id_plugin_1 = require("../../now-id-plugin");
+const node_zlib_1 = require("node:zlib");
+const complex_object_resolver_1 = require("../utils/complex-object-resolver");
+const utils_1 = require("../utils/utils");
+const schema_to_flow_object_1 = require("../utils/schema-to-flow-object");
+const flow_shapes_1 = require("../utils/flow-shapes");
+const inline_script_plugin_1 = require("./inline-script-plugin");
+const flow_constants_1 = require("../utils/flow-constants");
+/**
+ * Helper function to check if a field is hidden based on visible or visible_in_fd attributes
+ * @param attributes The attributes string from the field definition
+ * @returns true if the field has visible='false' or visible_in_fd='false'
+ */
+function isHiddenField(attributes) {
+    if (!attributes) {
+        return false;
+    }
+    const visibleAttr = (0, schema_to_flow_object_1.getAttributeValue)(attributes, 'visible');
+    const visibleInFdAttr = (0, schema_to_flow_object_1.getAttributeValue)(attributes, 'visible_in_fd');
+    return visibleAttr === 'false' || visibleInFdAttr === 'false';
+}
+/**
+ * Parses a complex object format where values are nested under $cv.$v
+ * @param obj The complex object to parse
+ * @returns A simplified object with direct values
+ */
+function parseComplexObjectValues(obj) {
+    /**
+     * Recursively parse a value that may contain Flow Designer complex-object wrappers.
+     * Handles:
+     *   • Primitive values – returned as-is
+     *   • Objects with `$cv` – unwrap to `$cv.$v`
+     *   • Objects with `$COCollectionField` – treat as an array and recurse
+     *   • Arrays – recurse over each element
+     *   • Plain objects – recurse over each property
+     */
+    const parseValue = (val) => {
+        if (val === null || val === undefined) {
+            return val;
+        }
+        // Arrays – recurse element-wise
+        if (Array.isArray(val)) {
+            return val.map(parseValue);
+        }
+        // Objects
+        if (typeof val === 'object') {
+            const obj = val;
+            // Direct complex-value wrapper
+            if ('$cv' in obj) {
+                const cv = obj['$cv'];
+                return parseValue(cv?.['$v']);
+            }
+            // Flow Designer collection array wrapper
+            if ('$COCollectionField' in obj) {
+                return parseValue(obj['$COCollectionField']);
+            }
+            // Plain object – recurse on each property
+            const out = {};
+            for (const [k, v] of Object.entries(val)) {
+                out[k] = parseValue(v);
+            }
+            return out;
+        }
+        // Primitive
+        return val;
+    };
+    return parseValue(obj);
+}
+/**
+ * Normalize raw input value based on uiType.
+ * - Attempts to JSON.parse strings.
+ * - Resolves FlowDesigner complexObject structures via parseComplexObjectValues.
+ * - For array uiTypes, ensures the result is an array (falling back to raw).
+ * - For glide_time, parses the time string and returns a TimeShape object.
+ * - For glide_duration, parses the duration string and returns a DurationShape object.
+ * - For template_value, parses the time string and returns a TemplateValueShape object.
+ */
+function normalizeInputValue(value, uiType, source, logger) {
+    // Handle glide_time type specially - parse the time string and return TimeShape
+    if (source) {
+        try {
+            if (uiType === flow_constants_1.TIME_DATA_TYPE_VALUE) {
+                // Create a StringShape from the value and use TimeShape.from() to parse it.
+                // Uses UTC timezone value to show in fluent flow to be in sync with Flow designer UI
+                return sdk_build_core_1.TimeShape.from(source, sdk_build_core_1.Shape.from(source, value).asString(), flow_constants_1.UTC_TIMEZONE_VALUE);
+            }
+            else if (uiType === flow_constants_1.DURATION_DATA_TYPE_VALUE) {
+                // Create a StringShape from the value and use DurationShape.from() to parse it
+                return sdk_build_core_1.DurationShape.from(source, sdk_build_core_1.Shape.from(source, value).asString());
+            }
+            else if (uiType === flow_constants_1.TEMPLATE_DATA_TYPE_VALUE) {
+                // Create a StringShape from the value and use TemplateValueShape.from() to parse it
+                return sdk_build_core_1.TemplateValueShape.from(source, sdk_build_core_1.Shape.from(source, value).asString());
+            }
+            else if (uiType === flow_constants_1.APPROVAL_RULES_DATA_TYPE_VALUE) {
+                // Create a StringShape from the value and use ApprovalRulesShape.from() to parse it
+                return flow_shapes_1.ApprovalRulesShape.from(source, sdk_build_core_1.Shape.from(source, value).asString());
+            }
+            else if (uiType === flow_constants_1.APPROVAL_DUE_DATE_DATA_TYPE_VALUE) {
+                // Check if source is a Record before accessing action_type
+                if (source instanceof sdk_build_core_1.Record) {
+                    const actionType = source.get(flow_constants_1.ACTION_TYPE_KEY_NAME)?.ifDefined()?.asString()?.getValue();
+                    if (flow_constants_1.APPROVAL_DUE_DATE_INPUT_FIELD_ACTIONS.includes(actionType)) {
+                        // Create a StringShape from the value and use ApprovalDueDateShape.from() to parse it
+                        return flow_shapes_1.ApprovalDueDateShape.from(source, sdk_build_core_1.Shape.from(source, value).asString());
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // If parsing fails, fall through to normal handling
+            logger?.error(`Failed to parse value ${value} for ${uiType} in record ${source}: ${e instanceof Error ? e.message : e}`);
+            return value;
+        }
+    }
+    let parsed = value;
+    try {
+        if (uiType !== 'string') {
+            parsed = JSON.parse(value);
+        }
+    }
+    catch {
+        // handle internal string types
+        if (uiType === 'glide_list') {
+            // comma separated sys_ids – return [] if empty
+            return value && value.trim() !== '' ? value.split(',') : [];
+        }
+        return value; // any string literal value (other than a valid stringified JSON)
+    }
+    if (parsed && typeof parsed === 'object' && 'complexObject' in parsed) {
+        return parseComplexObjectValues(parsed.complexObject);
+    }
+    if (uiType?.startsWith('array')) {
+        return Array.isArray(parsed) ? parsed : value;
+    }
+    /**
+     * Handle internal non-string types for primitive data types
+     * Ex. Instances store boolean values as '1' or '0' instead of true or false. But we show it as true/false in UI/fluent
+     */
+    if (uiType === 'boolean') {
+        parsed = Boolean(parsed); // 1 or true = true, 0 or false = false
+    }
+    return parsed;
+}
+function buildInstanceToShape({ defColumn, // e.g. "action_type" | "subflow"
+inputsTableName, // e.g. "sys_hub_action_input" | "sys_hub_flow_input"
+zippedColumn, // e.g. "values" | "subflow_inputs"
+callee, // "wfa.action" | "wfa.subflow"
+ }) {
+    return function toShape(record, { database, logger }) {
+        // Resolve the instance definition - either from the source shape or from the database record
+        const source = record.getSource();
+        const instanceDef = source instanceof flow_shapes_1.ActionSubflowInstanceShape
+            ? source.getInstanceDefinition()
+            : record.get(defColumn)?.ifDefined()?.asString();
+        const definitionInputs = instanceDef instanceof sdk_build_core_1.Record
+            ? instanceDef.flat().filter((v) => v.getTable() === inputsTableName)
+            : undefined;
+        const zippedInputs = record.get(zippedColumn)?.ifString()?.getValue() ?? '';
+        // ── Identifier discovery ────────────────────────────────────────────────
+        let identifierShapeOrSysId = instanceDef;
+        if (instanceDef instanceof sdk_build_core_1.Record) {
+            // check for core actions in existing fluent code, if so below condition will keep the existing identifier.
+            // Otherwise action.core.log will be replaced with the log.
+            const sysId = instanceDef.getId().getValue();
+            const coreActionIdentifier = (0, utils_1.getCoreActionIdentifier)(sysId);
+            if (coreActionIdentifier) {
+                identifierShapeOrSysId = new sdk_build_core_1.IdentifierShape({
+                    source: record,
+                    name: coreActionIdentifier,
+                });
+            }
+            else {
+                const original = instanceDef.getOriginalSource();
+                if (sdk_build_core_1.ts.Node.isNode(original)) {
+                    const varDecl = original.getFirstAncestorByKind(sdk_build_core_1.ts.SyntaxKind.VariableDeclaration);
+                    const idNode = varDecl?.getNameNode();
+                    if (idNode) {
+                        identifierShapeOrSysId = new sdk_build_core_1.IdentifierShape({
+                            source: idNode,
+                            name: idNode.getText(),
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            // When definition is not a Record, try to resolve from database by sys_id
+            if (defColumn === flow_constants_1.ACTION_DEF_COLUMN_NAME) {
+                const sysId = instanceDef?.ifString()?.getValue();
+                if (!sysId) {
+                    return { success: false };
+                }
+                const coreActionIdentifier = (0, utils_1.getCoreActionIdentifier)(sysId);
+                if (callee === flow_constants_1.ACTION_INSTANCE_API_NAME && !coreActionIdentifier) {
+                    logger.warn(`Custom actions are not supported, action = ${sysId}`);
+                    return { success: false };
+                }
+                const action = database
+                    .query('sys_hub_action_type_definition')
+                    .find((v) => v.getId().getValue() === sysId);
+                const actionSource = action?.getSource();
+                if (actionSource instanceof sdk_build_core_1.CallExpressionShape) {
+                    const identifierName = (0, utils_1.getIdentifierFromShape)(actionSource);
+                    if (identifierName) {
+                        identifierShapeOrSysId = new sdk_build_core_1.IdentifierShape({
+                            source: actionSource.getOriginalSource(),
+                            name: identifierName,
+                        });
+                    }
+                }
+                else if (coreActionIdentifier) {
+                    //Special case handling for core actions
+                    identifierShapeOrSysId = new sdk_build_core_1.IdentifierShape({ source: record, name: coreActionIdentifier });
+                }
+            }
+            else if (defColumn === 'subflow') {
+                const sysId = instanceDef?.getValue();
+                const subflow = database.query('sys_hub_flow').find((v) => v.getId().getValue() === sysId);
+                const actionSource = subflow?.getSource();
+                if (actionSource instanceof sdk_build_core_1.CallExpressionShape) {
+                    const identifierName = (0, utils_1.getIdentifierFromShape)(actionSource);
+                    if (identifierName) {
+                        identifierShapeOrSysId = new sdk_build_core_1.IdentifierShape({
+                            source: actionSource.getOriginalSource(),
+                            name: identifierName,
+                        });
+                    }
+                }
+            }
+        }
+        let inputsShape = buildInputsShapeFromZipped({
+            zippedInputs,
+            definitionInputs,
+            record,
+            logger,
+        });
+        if (inputsShape === undefined) {
+            return { success: false };
+        }
+        const waitForCompletion = record.get('wait_for_completion')?.getValue() === true ||
+            record.get('wait_for_completion')?.getValue() === 'true';
+        if (waitForCompletion) {
+            inputsShape = inputsShape
+                ? inputsShape.merge({ waitForCompletion })
+                : sdk_build_core_1.Shape.from(record, { waitForCompletion }).asObject();
+        }
+        const configArg = new sdk_build_core_1.ObjectShape({
+            source: record,
+            properties: record.transform(({ $ }) => ({
+                $id: $.val(now_id_plugin_1.NowIdShape.from(record)),
+                annotation: $.from('comment').def(''),
+                uuid: $.from('ui_id').def(''),
+            })),
+        });
+        // Create the CallExpressionShape for the action/subflow instance
+        const callExpression = new sdk_build_core_1.CallExpressionShape({
+            source: record,
+            callee,
+            args: [identifierShapeOrSysId, configArg, inputsShape],
+        });
+        // Generate variable name from existing source or fallback to callee + ID
+        const order = record.get('order')?.getValue();
+        let identifierPrefix = '';
+        if (callee.toLowerCase() === flow_constants_1.ACTION_INSTANCE_API_NAME) {
+            identifierPrefix = 'action';
+        }
+        else if (callee.toLowerCase() === flow_constants_1.SUBFLOW_INSTANCE_API_NAME) {
+            identifierPrefix = 'subflow';
+        }
+        // Use getDirectVariableIdentifier to only check direct parent VariableDeclaration
+        // This prevents actions inside Subflows from inheriting the parent Subflow's variable name
+        const variableName = (0, utils_1.getDirectVariableIdentifier)(record.getOriginalSource()) ?? `${identifierPrefix}Instance_${order}`; // _${instanceId.slice(0, 8)}`
+        // Wrap in VariableStatementShape with isExported: false
+        return {
+            success: true,
+            value: new sdk_build_core_1.VariableStatementShape({
+                source: record,
+                variableName,
+                initializer: callExpression,
+                isExported: false,
+            }),
+        };
+    };
+}
+exports.FlowInstancePlugin = sdk_build_core_1.Plugin.create({
+    name: 'FlowInstancePlugin',
+    records: {
+        sys_hub_action_instance_v2: {
+            toShape: buildInstanceToShape({
+                defColumn: flow_constants_1.ACTION_DEF_COLUMN_NAME,
+                inputsTableName: 'sys_hub_action_input',
+                zippedColumn: 'values',
+                callee: flow_constants_1.ACTION_INSTANCE_API_NAME,
+            }),
+        },
+        sys_hub_sub_flow_instance_v2: {
+            toShape: buildInstanceToShape({
+                defColumn: 'subflow',
+                inputsTableName: 'sys_hub_flow_input',
+                zippedColumn: 'subflow_inputs',
+                callee: flow_constants_1.SUBFLOW_INSTANCE_API_NAME,
+            }),
+        },
+    },
+    shapes: [
+        {
+            // Look for FDInstanceShape and return instance records as needed for Flow plugin
+            shape: flow_shapes_1.ActionSubflowInstanceShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { factory, transform, diagnostics, logger }) {
+                const instanceType = callExpression.getInstanceType();
+                // Shortcut for unsupported instance types
+                if (instanceType !== flow_constants_1.ACTION_INSTANCE_API_NAME && instanceType !== flow_constants_1.SUBFLOW_INSTANCE_API_NAME) {
+                    return { success: false };
+                }
+                const instanceParentDef = callExpression.getInstanceDefinition();
+                const instanceSysId = callExpression.getSysId();
+                const instanceInputs = callExpression.getInstanceProps();
+                const instanceAnnotation = callExpression.getAnnotation()?.getValue();
+                const instanceUUID = callExpression.getInstanceUUID()?.getValue();
+                if (!instanceInputs || !instanceSysId || !instanceParentDef) {
+                    diagnostics.error(callExpression, `Failed to extract inputs, sysId, or definition from ${instanceType}`);
+                    return { success: false };
+                }
+                let instanceRecord;
+                if (instanceType === flow_constants_1.ACTION_INSTANCE_API_NAME) {
+                    instanceRecord = await buildActionInstance({
+                        actionDef: instanceParentDef,
+                        inputs: instanceInputs,
+                        sysId: instanceSysId,
+                        annotation: instanceAnnotation,
+                        uuid: instanceUUID,
+                        factory,
+                        source: callExpression,
+                        transform,
+                        logger,
+                    });
+                }
+                else if (instanceType === flow_constants_1.SUBFLOW_INSTANCE_API_NAME) {
+                    instanceRecord = await buildSubflowInstance({
+                        subflowDef: instanceParentDef,
+                        inputs: instanceInputs,
+                        sysId: instanceSysId,
+                        annotation: instanceAnnotation,
+                        uuid: instanceUUID,
+                        factory,
+                        source: callExpression,
+                        transform,
+                    });
+                }
+                return instanceRecord ? { success: true, value: instanceRecord } : { success: false };
+            },
+        },
+    ],
+});
+// -------------------------
+// Shared helpers
+// -------------------------
+/**
+ * Builds an FDInlineScriptCallShape from XML inline script data.
+ *
+ * **Inline Script Detection:**
+ * Detects inputs with `scriptActive: true` and extracts the script content from
+ * the `script[fieldName].script` property. Creates an FDInlineScriptCallShape that represents
+ * `wfa.inlineScript('script content')` in Fluent code.
+ *
+ * @param fieldName - The name of the input field
+ * @param scriptActive - Whether this field contains an active script
+ * @param script - The script object containing script content keyed by field name
+ * @param source - The source Record for creating the shape
+ * @returns FDInlineScriptCallShape if this is an inline script, undefined otherwise
+ */
+function buildInlineScriptShapeFromXml(fieldName, scriptActive, script, source) {
+    if (scriptActive === true && script && script[fieldName]?.script) {
+        const scriptContent = script[fieldName].script;
+        return new inline_script_plugin_1.FDInlineScriptCallShape({
+            source,
+            scriptContent,
+        });
+    }
+    return undefined;
+}
+/**
+ * Build an ObjectShape representing instance inputs from a base64-zipped JSON payload.
+ * This is used by both subflow and action instances.
+ * Supports bi-directional conversion for inline scripts (XML ↔ Fluent).
+ */
+function buildInputsShapeFromZipped({ zippedInputs, definitionInputs, record, logger, }) {
+    if (!zippedInputs) {
+        return undefined;
+    }
+    const props = {};
+    try {
+        const unzipped = (0, node_zlib_1.gunzipSync)(Buffer.from(zippedInputs, 'base64')).toString();
+        const values = JSON.parse(unzipped);
+        for (const { name, value, scriptActive, script, parameter } of values) {
+            const attributes = definitionInputs
+                ?.find((v) => v.get('element').asString()?.getValue() === name)
+                ?.get('attributes')
+                ?.ifString()
+                ?.getValue();
+            const uiType = attributes ? (0, schema_to_flow_object_1.getAttributeValue)(attributes, 'uiType') : undefined;
+            // Skip hidden fields during transformation
+            // Convert parameter.attributes object to string format (key=value,key=value)
+            const paramAttributesStr = parameter?.attributes
+                ? Object.entries(parameter.attributes)
+                    .map(([key, value]) => `${key}=${value}`)
+                    .join(',')
+                : undefined;
+            if (isHiddenField(attributes) || isHiddenField(paramAttributesStr)) {
+                continue;
+            }
+            try {
+                if (flow_constants_1.UNSUPPORTED_DATA_TYPES.includes(parameter?.type)) {
+                    logger.warn(`input ${name} has unsupported data type ${parameter?.type}`);
+                    return undefined;
+                }
+                // Check if this is an inline script and convert to wfa.inlineScript() format
+                const inlineScriptShape = buildInlineScriptShapeFromXml(name, scriptActive, script, record);
+                if (inlineScriptShape) {
+                    props[name] = inlineScriptShape;
+                }
+                else {
+                    // Use displayValue for proper type conversion (e.g., boolean: '1' → true)
+                    props[name] = normalizeInputValue(value, uiType ?? parameter.type, record, logger);
+                }
+            }
+            catch (e) {
+                const recordInfo = `${record.getTable()}.${record.getId().getValue()}`;
+                logger.warn(`Failed to parse value for ${name} in record ${recordInfo}: ${e instanceof Error ? e.message : e}`);
+                props[name] = value;
+            }
+        }
+        return new sdk_build_core_1.ObjectShape({ source: record, properties: props });
+    }
+    catch (error) {
+        logger.error(`Malformed/unsupported input payload in subflow_inputs: ${error}`);
+        return undefined;
+    }
+}
+// -------------------------
+// Helper builders
+// -------------------------
+async function buildActionInstance({ actionDef, inputs, sysId, annotation, uuid, factory, source, transform, logger, }) {
+    const values = actionDef ? await prepareActionInstanceValueJson(inputs, actionDef, transform, logger) : undefined;
+    const actionDefRecord = actionDef instanceof sdk_build_core_1.Record ? actionDef : undefined;
+    const instanceProps = inputs.transform(({ $ }) => ({
+        active: $.val(true),
+        // if actionDef is not a Record (sysId fallback cases), actionDef?.getValue() should get get the string value (sysId) as is
+        action_type: $.val(actionDefRecord?.getId()?.getValue() || actionDef?.getValue() || ''),
+        action_type_parent: $.val(actionDefRecord?.getId()?.getValue() || actionDef?.getValue() || ''),
+        comment: $.val(annotation || actionDefRecord?.get('comment')?.getValue() || ''),
+        display_text: $.val(''),
+        generation_source: $.val(''),
+        sys_class_name: $.val('sys_hub_action_instance_v2'),
+        updation_source: $.val(''),
+        values: $.val(values),
+        parent_ui_id: $.val(''),
+    }));
+    if (!instanceProps) {
+        return undefined;
+    }
+    const record = await factory.createRecord({
+        source,
+        explicitId: sysId,
+        table: 'sys_hub_action_instance_v2',
+        properties: instanceProps,
+    });
+    // UUID can come from either instance uuid property (for fd ui authored actions) or generated from sysid (for fluent authored actions).
+    const instanceUUID = uuid ? uuid : (0, utils_1.sysIdToUuid)(record.getId().getValue());
+    return record.merge({ ui_id: instanceUUID });
+}
+async function buildSubflowInstance({ subflowDef, inputs, sysId, annotation, factory, uuid, source, transform, }) {
+    const values = subflowDef ? await prepareSubflowInstanceValueJson(inputs, subflowDef, transform) : undefined;
+    const subflowDefRecord = subflowDef instanceof sdk_build_core_1.Record ? subflowDef : undefined;
+    const instanceProps = inputs.transform(({ $ }) => ({
+        order: $.val(1),
+        flow: $.val(''),
+        attributes: $.val(''),
+        comment: $.val(annotation || subflowDefRecord?.get('comment')?.getValue() || ''),
+        display_text: $.val(''),
+        generation_source: $.val(''),
+        subflow: $.val(subflowDefRecord?.getId()?.getValue() || subflowDef?.getValue() || ''),
+        subflow_inputs: $.val(values),
+        wait_for_completion: $.from('waitForCompletion').def(false),
+        sys_class_name: $.val('sys_hub_sub_flow_instance_v2'),
+        parent_ui_id: $.def(''),
+    }));
+    if (!instanceProps) {
+        return undefined;
+    }
+    const record = await factory.createRecord({
+        source,
+        explicitId: sysId,
+        table: 'sys_hub_sub_flow_instance_v2',
+        properties: instanceProps,
+    });
+    // UUID can come from either instance uuid property (for fd ui authored subflows) or generated from sysid (for fluent authored subflows).
+    const instanceUUID = uuid ? uuid : (0, utils_1.sysIdToUuid)(record.getId().getValue());
+    return record.merge({ ui_id: instanceUUID });
+}
+/**
+ * Checks for inline script patterns in the input properties and resolves them
+ * to their appropriate format (either script format or primitive value).
+ *
+ * Supports inline scripts via wfa.inlineScript('script') (detected as CallExpressionShape/FDInlineScriptCallShape).
+ *
+ * Architecture note:
+ * This function detects inline scripts based on context - only template literals and Now.include()
+ * calls used as Action/Subflow inputs are treated as inline scripts. This avoids incorrectly
+ * converting template literals used elsewhere in the codebase (logging, formatting, etc.).
+ *
+ * Similar to data pills processing, this function:
+ * - Uses .entries({ resolve: false }) to preserve shape types
+ * - Checks if each shape is a TemplateExpressionShape or Now.include() call
+ * - Returns special serialization format for inline scripts
+ * - Falls back to regular getValue() for non-script shapes
+ *
+ * @param instanceInputs - The ObjectShape containing input properties
+ * @param transform - Transform context for shape conversion
+ * @returns Array of [name, value] tuples where inline scripts are serialized appropriately
+ */
+async function checkAndResolveInlineScripts(instanceInputs, _transform) {
+    const entries = instanceInputs.entries({ resolve: false });
+    const results = [];
+    for (const [key, shape] of entries) {
+        // Handle wfa.inlineScript() calls - they should already be FDInlineScriptCallShape after plugin processing
+        if (shape instanceof inline_script_plugin_1.FDInlineScriptCallShape) {
+            const scriptContent = shape.getValue();
+            if (typeof scriptContent === 'string') {
+                // Wrap the script content in a TemplateExpressionShape
+                const templateShape = new sdk_build_core_1.TemplateExpressionShape({
+                    source: shape,
+                    literalText: scriptContent,
+                });
+                // Create InlineScriptShape for Flow Designer serialization
+                const inlineScript = new flow_shapes_1.InlineScriptShape({
+                    source: templateShape,
+                    scriptContent,
+                });
+                const scriptValue = inlineScript.toFlowDesignerJson(key);
+                results.push([key, scriptValue]);
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Resolves complex object input values for subflow/action instance preparation.
+ * @param name - Input field name
+ * @param value - Raw input value
+ * @param parentDef - Record containing input and complex object definitions
+ * @param inputTableName - Table name to look up input definitions (e.g. 'sys_hub_flow_input' or 'sys_hub_action_input')
+ */
+// Deprecated: kept for backward-compat but delegates to shared resolver
+function resolveComplexInput(name, value, parentDef, inputTableName, logger) {
+    return (0, complex_object_resolver_1.resolveComplexInput)(name, value, parentDef, inputTableName, undefined, logger);
+}
+/**
+ * Checks if a given value is a serialized inline script object.
+ * This is used to identify inputs that have already been processed into the final
+ * Flow Designer JSON format for scripts.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a script object, `false` otherwise.
+ */
+function isInlineScriptValue(value) {
+    return typeof value === 'object' && value !== null && value.scriptActive === true;
+}
+/**
+ * Processes an input value from objShape and returns the appropriate result object.
+ * Handles inline scripts by returning them as-is, or creates a standard input object.
+ *
+ * @param inputName - The name of the input field
+ * @param objShape - The ObjectShape containing all input values
+ * @param options - Optional processing options
+ * @param options.type - The parameter type to use (defaults to 'string' if not provided)
+ * @param options.actionDefRecord - Action definition record for complex input resolution
+ * @param options.inputTableName - Table name for input definitions (e.g., 'sys_hub_action_input')
+ * @returns The processed input object
+ */
+function processInputValue(inputName, objShape, options) {
+    const value = objShape.get(inputName);
+    const primitiveValue = value.getValue();
+    // If it's an inline script object, return it as-is
+    if (isInlineScriptValue(primitiveValue)) {
+        return primitiveValue;
+    }
+    let finalValue = primitiveValue;
+    let finalType = options?.type ?? 'string';
+    // If action definition is provided, resolve complex input
+    if (options?.actionDefRecord && options?.inputTableName) {
+        const resolvedValue = resolveComplexInput(inputName, primitiveValue, options.actionDefRecord, options.inputTableName, options?.logger);
+        finalValue = resolvedValue.value;
+        finalType = resolvedValue.internalType;
+    }
+    // Return standard input object
+    return {
+        name: inputName,
+        value: finalValue,
+        displayValue: finalValue,
+        scriptActive: false,
+        parameter: {
+            type: finalType,
+        },
+    };
+}
+/**
+ * Processes a definition input that was not provided by the user.
+ * Handles hidden fields and default values by creating appropriate input objects.
+ *
+ * @param inputDef - The input definition record from the action/subflow definition
+ * @param inputName - The name of the input field
+ * @returns The processed input object if the field is hidden or has a default value, undefined otherwise
+ */
+function processDefaultOrHiddenInput(inputDef, inputName) {
+    // Get attributes and check if hidden
+    const attributes = inputDef.get('attributes')?.ifString()?.getValue();
+    const visibleAttr = attributes ? (0, schema_to_flow_object_1.getAttributeValue)(attributes, 'visible') : undefined;
+    const visibleInFdAttr = attributes ? (0, schema_to_flow_object_1.getAttributeValue)(attributes, 'visible_in_fd') : undefined;
+    const isHidden = visibleAttr === 'false' || visibleInFdAttr === 'false';
+    // Get default value and internal type
+    const defaultValue = inputDef.get('default_value')?.getValue();
+    const hasDefaultValue = defaultValue !== undefined && defaultValue !== null && defaultValue !== '';
+    const internalType = inputDef.get('internal_type')?.asString()?.getValue() || 'string';
+    // For hidden fields or fields with default values, add them to result
+    if (isHidden || hasDefaultValue) {
+        const valueToUse = hasDefaultValue ? defaultValue : '';
+        const paramAttributes = {};
+        if (visibleAttr === 'false') {
+            paramAttributes.visible = false;
+        }
+        if (visibleInFdAttr === 'false') {
+            paramAttributes.visible_in_fd = false;
+        }
+        return {
+            name: inputName,
+            value: valueToUse,
+            displayValue: valueToUse,
+            scriptActive: false,
+            parameter: {
+                type: internalType,
+                ...(Object.keys(paramAttributes).length > 0 && { attributes: paramAttributes }),
+            },
+        };
+    }
+    return undefined;
+}
+async function prepareActionInstanceValueJson(instanceInputs, actionDef, transform, logger) {
+    const actionDefRecord = actionDef.isRecord() ? actionDef.as(sdk_build_core_1.Record) : undefined;
+    if (!instanceInputs) {
+        return [];
+    }
+    const isActionDefString = actionDef instanceof sdk_build_core_1.StringShape;
+    // Check for datapills and resolve them
+    const dataPillResults = await checkAndResolveDataPills(instanceInputs, transform);
+    // Check for inline script tags and resolve them (only returns scripts)
+    const inlineScriptResults = await checkAndResolveInlineScripts(instanceInputs, transform);
+    const inlineScriptMap = new Map(inlineScriptResults);
+    // Merge: use inline scripts where they exist, otherwise use datapill results
+    // Note: Inline script can be applied to only top level properties; No need to handle nested objects
+    const mergedResults = dataPillResults.map(([key, value]) => {
+        return inlineScriptMap.has(key) ? [key, inlineScriptMap.get(key)] : [key, value];
+    });
+    const objShape = new sdk_build_core_1.ObjectShape({
+        source: instanceInputs.getSource(),
+        properties: Object.fromEntries(mergedResults),
+    });
+    const result = [];
+    // When isActionDefString is true, there's no action definition in fluent
+    // We expect arbitrary inputs and should process all provided inputs directly
+    if (actionDefRecord) {
+        // When action definition record is present, process only definition inputs
+        const definitionInputs = actionDefRecord.flat().filter((v) => v.getTable() === 'sys_hub_action_input');
+        const providedInputNames = new Set(objShape.keys());
+        for (const inputDef of definitionInputs) {
+            const inputName = inputDef.get('element')?.asString()?.getValue();
+            if (!inputName) {
+                continue;
+            }
+            // If input is provided in objShape(ie provided by user), process it
+            if (providedInputNames.has(inputName)) {
+                const processedValue = processInputValue(inputName, objShape, {
+                    actionDefRecord,
+                    inputTableName: 'sys_hub_action_input',
+                    logger,
+                });
+                result.push(processedValue);
+            }
+            else {
+                // Process default or hidden input
+                const processedValue = processDefaultOrHiddenInput(inputDef, inputName);
+                if (processedValue) {
+                    result.push(processedValue);
+                }
+            }
+        }
+    }
+    else if (isActionDefString) {
+        for (const inputName of objShape.keys()) {
+            const processedValue = processInputValue(inputName, objShape, { type: 'string' });
+            result.push(processedValue);
+        }
+    }
+    return result;
+}
+async function prepareSubflowInstanceValueJson(instanceInputs, subflowDef, transform) {
+    // Check for datapills and resolve them
+    const dataPillResults = await checkAndResolveDataPills(instanceInputs, transform);
+    // Check for inline script tags and resolve them (only returns scripts)
+    const inlineScriptResults = await checkAndResolveInlineScripts(instanceInputs, transform);
+    const inlineScriptMap = new Map(inlineScriptResults);
+    // Merge: use inline scripts where they exist, otherwise use datapill results
+    const mergedResults = dataPillResults.map(([key, value]) => {
+        return inlineScriptMap.has(key) ? [key, inlineScriptMap.get(key)] : [key, value];
+    });
+    const objShape = new sdk_build_core_1.ObjectShape({
+        source: instanceInputs.getSource(),
+        properties: Object.fromEntries(mergedResults),
+    });
+    return objShape
+        .keys()
+        .filter((key) => key !== 'waitForCompletion')
+        .map((key) => {
+        const value = objShape.get(key);
+        const primitiveValue = value.getValue();
+        // If checkAndResolveInlineScripts already returned a script object, return it as-is
+        if (isInlineScriptValue(primitiveValue)) {
+            return primitiveValue;
+        }
+        let resolvedValue = {
+            value: primitiveValue,
+            internalType: undefined,
+        };
+        if (subflowDef.isRecord()) {
+            resolvedValue = resolveComplexInput(key, primitiveValue, subflowDef.as(sdk_build_core_1.Record), 'sys_hub_flow_input');
+        }
+        const result = {
+            name: key,
+            value: resolvedValue.value,
+            displayValue: resolvedValue.value,
+            parameter: {
+                type: resolvedValue.internalType,
+            }, // populate later if needed
+        };
+        // Add children array if present (for FlowObject with datapills)
+        if (resolvedValue.children && resolvedValue.children.length > 0) {
+            result['children'] = resolvedValue.children;
+        }
+        return result;
+    });
+}
+/**
+ * Type guard to check if a shape is a data pill shape that needs resolution.
+ * Data pill shapes include PropertyAccessShape, TemplateExpressionShape, and IdentifierShape.
+ * @param shape - The shape to check
+ * @returns true if the shape is a data pill shape, false otherwise
+ */
+function isDataPillShape(shape) {
+    return (shape instanceof sdk_build_core_1.PropertyAccessShape ||
+        shape instanceof sdk_build_core_1.TemplateExpressionShape ||
+        shape instanceof sdk_build_core_1.IdentifierShape);
+}
+/**
+ * Recursively resolves data pills in nested object structures.
+ * Handles objects with nested data pills and constructs the resolved object back.
+ * Special shapes like TemplateValueShape and ApprovalRulesShape are also processed recursively
+ * since they can contain data pills in their nested structures.
+ * @param shape - The ObjectShape to process
+ * @param transform - The transform instance
+ * @returns Resolved object with all nested data pills resolved
+ */
+async function resolveObjectShapeRecursively(shape, transform) {
+    const entries = shape.entries({ resolve: false });
+    const resolvedObject = {};
+    for (const [key, valueShape] of entries) {
+        if (isDataPillShape(valueShape)) {
+            // Resolve data pill shapes
+            resolvedObject[key] = await (0, utils_1.resolveDataPillShape)(valueShape, transform);
+        }
+        else if (valueShape.isObject()) {
+            // Recursively resolve all ObjectShapes including special types
+            // TemplateValueShape and ApprovalRulesShape can contain data pills in their nested structures
+            // DurationShape only contains primitive numbers, but handling it recursively is harmless
+            resolvedObject[key] = await resolveObjectShapeRecursively(valueShape.asObject(), transform);
+        }
+        else if (valueShape.isArray()) {
+            // Handle array: recursively resolve each element
+            const arrayShape = valueShape.asArray();
+            const elements = arrayShape.getElements(false);
+            const resolvedArray = [];
+            for (const element of elements) {
+                if (isDataPillShape(element)) {
+                    resolvedArray.push(await (0, utils_1.resolveDataPillShape)(element, transform));
+                }
+                else if (element.isObject()) {
+                    resolvedArray.push(await resolveObjectShapeRecursively(element.asObject(), transform));
+                }
+                else if (element.isArray()) {
+                    // Recursively handle nested arrays by creating a temporary ObjectShape wrapper
+                    const tempShape = new sdk_build_core_1.ObjectShape({
+                        source: element.getSource(),
+                        properties: { temp: element },
+                    });
+                    const resolved = await resolveObjectShapeRecursively(tempShape, transform);
+                    resolvedArray.push(resolved.temp);
+                }
+                else {
+                    resolvedArray.push(element.getValue());
+                }
+            }
+            resolvedObject[key] = resolvedArray;
+        }
+        else {
+            // For all other shapes (primitives), get the value directly
+            resolvedObject[key] = valueShape.getValue();
+        }
+    }
+    return resolvedObject;
+}
+/**
+ * Wraps special shape types (ApprovalRulesShape, TemplateValueShape, DurationShape) with their string representations.
+ * @param shape - The original shape
+ * @param resolvedValue - The resolved value
+ * @param source - The source for creating new shapes
+ * @returns The appropriately wrapped value or the original resolved value
+ */
+function wrapSpecialShape(shape, resolvedValue, source) {
+    if (shape.is(flow_shapes_1.ApprovalRulesShape)) {
+        return new flow_shapes_1.ApprovalRulesShape({
+            source,
+            value: resolvedValue,
+        }).toString();
+    }
+    else if (shape.is(sdk_build_core_1.TemplateValueShape)) {
+        return new sdk_build_core_1.TemplateValueShape({
+            source,
+            value: resolvedValue,
+        }).toString();
+    }
+    else if (shape.is(sdk_build_core_1.DurationShape)) {
+        return new sdk_build_core_1.DurationShape({
+            source,
+            value: resolvedValue,
+        }).toString();
+    }
+    else if (shape.is(flow_shapes_1.ApprovalDueDateShape)) {
+        return new flow_shapes_1.ApprovalDueDateShape({
+            source,
+            value: resolvedValue,
+        }).toString();
+    }
+    return resolvedValue;
+}
+/**
+ * Checks for datapills and resolves them in instance inputs.
+ * Similar to resolveObjectShapeRecursively but returns key-value pairs and handles special shapes.
+ * @param instanceInputs - The instance inputs object shape
+ * @param transform - The transform instance
+ * @returns Array of [key, value] pairs with resolved datapills
+ */
+async function checkAndResolveDataPills(instanceInputs, transform) {
+    const entries = instanceInputs.entries({ resolve: false });
+    const results = [];
+    for (const [key, shape] of entries) {
+        if (shape && isDataPillShape(shape)) {
+            const resolvedValue = await (0, utils_1.resolveDataPillShape)(shape, transform);
+            results.push([key, resolvedValue]);
+        }
+        else if (shape.is(sdk_build_core_1.DurationShape)) {
+            // Handle DurationShape specially - convert to string representation
+            // DurationShape.getValue() returns a symbol, so we need to get the duration value differently
+            const durationShape = shape.as(sdk_build_core_1.DurationShape);
+            const durationValue = durationShape.getDuration();
+            const wrappedValue = wrapSpecialShape(shape, durationValue, instanceInputs.getSource());
+            results.push([key, wrappedValue]);
+        }
+        else if (shape.isObject() || shape.is(sdk_build_core_1.TemplateValueShape)) {
+            const objShape = shape.is(sdk_build_core_1.TemplateValueShape) ? shape.getTemplateValue() : shape.asObject();
+            // Recursively resolve object shapes
+            const resolvedValue = await resolveObjectShapeRecursively(objShape, transform);
+            // Preserve special shapes like TemplateValue by passing the original shape
+            const wrappedValue = wrapSpecialShape(shape, resolvedValue, instanceInputs.getSource());
+            results.push([key, wrappedValue]);
+        }
+        else if (shape.isArray()) {
+            // Resolve arrays using the shared recursive logic
+            const resolvedArray = await resolveArrayElements(shape.asArray(), transform);
+            results.push([key, resolvedArray]);
+        }
+        else {
+            results.push([key, shape.getValue()]);
+        }
+    }
+    return results;
+}
+/**
+ * Resolves all elements in an array shape, handling datapills, objects, and nested arrays.
+ * Shared logic extracted from both resolveObjectShapeRecursively and checkAndResolveDataPills.
+ * @param arrayShape - The array shape to resolve
+ * @param transform - The transform instance
+ * @returns Resolved array with all datapills resolved
+ */
+async function resolveArrayElements(arrayShape, transform) {
+    const elements = arrayShape.asArray().getElements(false);
+    const resolvedArray = [];
+    for (const element of elements) {
+        if (isDataPillShape(element)) {
+            resolvedArray.push(await (0, utils_1.resolveDataPillShape)(element, transform));
+        }
+        else if (element.isObject()) {
+            resolvedArray.push(await resolveObjectShapeRecursively(element.asObject(), transform));
+        }
+        else if (element.isArray()) {
+            // Recursively handle nested arrays
+            resolvedArray.push(await resolveArrayElements(element, transform));
+        }
+        else {
+            resolvedArray.push(element.getValue());
+        }
+    }
+    return resolvedArray;
+}
+//# sourceMappingURL=flow-instance-plugin.js.map