@servicenow/sdk-build-plugins 4.1.1 → 4.3.0

package/src/flow/plugins/flow-instance-plugin.ts

@@ -0,0 +1,1148 @@
+import {
+    CallExpressionShape,
+    DurationShape,
+    type Factory,
+    IdentifierShape,
+    type Logger,
+    ObjectShape,
+    Plugin,
+    PropertyAccessShape,
+    Record,
+    type RecordContext,
+    type Result,
+    Shape,
+    type Source,
+    StringShape,
+    TemplateExpressionShape,
+    TemplateValueShape,
+    TimeShape,
+    type Transform,
+    ts,
+    VariableStatementShape,
+} from '@servicenow/sdk-build-core'
+import { NowIdShape } from '../../now-id-plugin'
+import { gunzipSync } from 'node:zlib'
+import { resolveComplexInput as _resolveComplexInput } from '../utils/complex-object-resolver'
+import {
+    getCoreActionIdentifier,
+    getDirectVariableIdentifier,
+    getIdentifierFromShape,
+    resolveDataPillShape,
+    sysIdToUuid,
+} from '../utils/utils'
+import { getAttributeValue } from '../utils/schema-to-flow-object'
+import {
+    ActionSubflowInstanceShape,
+    ApprovalRulesShape,
+    ApprovalDueDateShape,
+    InlineScriptShape,
+} from '../utils/flow-shapes'
+import { FDInlineScriptCallShape } from './inline-script-plugin'
+
+import {
+    ACTION_DEF_COLUMN_NAME,
+    ACTION_INSTANCE_API_NAME,
+    APPROVAL_RULES_DATA_TYPE_VALUE,
+    APPROVAL_DUE_DATE_DATA_TYPE_VALUE,
+    DURATION_DATA_TYPE_VALUE,
+    SUBFLOW_INSTANCE_API_NAME,
+    TEMPLATE_DATA_TYPE_VALUE,
+    TIME_DATA_TYPE_VALUE,
+    UNSUPPORTED_DATA_TYPES,
+    UTC_TIMEZONE_VALUE,
+    APPROVAL_DUE_DATE_INPUT_FIELD_ACTIONS,
+    ACTION_TYPE_KEY_NAME,
+} from '../utils/flow-constants'
+import type { ApprovalDueDateType, ApprovalRulesType } from '@servicenow/sdk-core/runtime/flow'
+import type { Duration } from '@servicenow/sdk-core/runtime/db'
+
+/**
+ * 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: string | undefined): boolean {
+    if (!attributes) {
+        return false
+    }
+    const visibleAttr = getAttributeValue(attributes, 'visible')
+    const visibleInFdAttr = 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: unknown): unknown {
+    /**
+     * 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: unknown): unknown => {
+        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 as globalThis.Record<string, unknown>
+            // Direct complex-value wrapper
+            if ('$cv' in obj) {
+                const cv = obj['$cv'] as globalThis.Record<string, unknown> | undefined
+                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: { [k: string]: unknown } = {}
+            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.
+ */
+export function normalizeInputValue(value: string, uiType?: string, source?: Source, logger?: Logger): unknown {
+    // Handle glide_time type specially - parse the time string and return TimeShape
+    if (source) {
+        try {
+            if (uiType === 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 TimeShape.from(source, Shape.from(source, value).asString(), UTC_TIMEZONE_VALUE)
+            } else if (uiType === DURATION_DATA_TYPE_VALUE) {
+                // Create a StringShape from the value and use DurationShape.from() to parse it
+                return DurationShape.from(source, Shape.from(source, value).asString())
+            } else if (uiType === TEMPLATE_DATA_TYPE_VALUE) {
+                // Create a StringShape from the value and use TemplateValueShape.from() to parse it
+                return TemplateValueShape.from(source, Shape.from(source, value).asString())
+            } else if (uiType === APPROVAL_RULES_DATA_TYPE_VALUE) {
+                // Create a StringShape from the value and use ApprovalRulesShape.from() to parse it
+                return ApprovalRulesShape.from(source, Shape.from(source, value).asString())
+            } else if (uiType === APPROVAL_DUE_DATE_DATA_TYPE_VALUE) {
+                // Check if source is a Record before accessing action_type
+                if (source instanceof Record) {
+                    const actionType = source.get(ACTION_TYPE_KEY_NAME)?.ifDefined()?.asString()?.getValue()
+                    if (APPROVAL_DUE_DATE_INPUT_FIELD_ACTIONS.includes(actionType as string)) {
+                        // Create a StringShape from the value and use ApprovalDueDateShape.from() to parse it
+                        return ApprovalDueDateShape.from(source, 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: unknown = 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"
+}: {
+    defColumn: string
+    inputsTableName: string
+    zippedColumn: string
+    callee: typeof ACTION_INSTANCE_API_NAME | typeof SUBFLOW_INSTANCE_API_NAME
+}) {
+    return function toShape(record: Record, { database, logger }: RecordContext): Result<Shape> {
+        // Resolve the instance definition - either from the source shape or from the database record
+        const source = record.getSource()
+        const instanceDef =
+            source instanceof ActionSubflowInstanceShape
+                ? source.getInstanceDefinition()
+                : record.get(defColumn)?.ifDefined()?.asString()
+
+        const definitionInputs =
+            instanceDef instanceof Record
+                ? instanceDef.flat().filter((v) => v.getTable() === inputsTableName)
+                : undefined
+
+        const zippedInputs = record.get(zippedColumn)?.ifString()?.getValue() ?? ''
+
+        // ── Identifier discovery ────────────────────────────────────────────────
+        let identifierShapeOrSysId: Shape | undefined = instanceDef
+        if (instanceDef instanceof 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 = getCoreActionIdentifier(sysId)
+            if (coreActionIdentifier) {
+                identifierShapeOrSysId = new IdentifierShape({
+                    source: record,
+                    name: coreActionIdentifier,
+                })
+            } else {
+                const original = instanceDef.getOriginalSource()
+                if (ts.Node.isNode(original)) {
+                    const varDecl = original.getFirstAncestorByKind(ts.SyntaxKind.VariableDeclaration)
+                    const idNode = varDecl?.getNameNode()
+                    if (idNode) {
+                        identifierShapeOrSysId = new IdentifierShape({
+                            source: idNode,
+                            name: idNode.getText(),
+                        })
+                    }
+                }
+            }
+        } else {
+            // When definition is not a Record, try to resolve from database by sys_id
+            if (defColumn === ACTION_DEF_COLUMN_NAME) {
+                const sysId = instanceDef?.ifString()?.getValue()
+                if (!sysId) {
+                    return { success: false }
+                }
+
+                const coreActionIdentifier = getCoreActionIdentifier(sysId)
+                if (callee === 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 CallExpressionShape) {
+                    const identifierName = getIdentifierFromShape(actionSource)
+                    if (identifierName) {
+                        identifierShapeOrSysId = new IdentifierShape({
+                            source: actionSource.getOriginalSource(),
+                            name: identifierName,
+                        })
+                    }
+                } else if (coreActionIdentifier) {
+                    //Special case handling for core actions
+                    identifierShapeOrSysId = new 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 CallExpressionShape) {
+                    const identifierName = getIdentifierFromShape(actionSource)
+                    if (identifierName) {
+                        identifierShapeOrSysId = new IdentifierShape({
+                            source: actionSource.getOriginalSource(),
+                            name: identifierName,
+                        })
+                    }
+                }
+            }
+        }
+
+        let inputsShape = buildInputsShapeFromZipped({
+            zippedInputs,
+            definitionInputs,
+            record,
+            logger,
+        })
+        if (inputsShape === undefined) {
+            return { success: false as const }
+        }
+        const waitForCompletion =
+            record.get('wait_for_completion')?.getValue() === true ||
+            record.get('wait_for_completion')?.getValue() === 'true'
+        if (waitForCompletion) {
+            inputsShape = inputsShape
+                ? inputsShape.merge({ waitForCompletion })
+                : Shape.from(record, { waitForCompletion }).asObject()
+        }
+
+        const configArg = new ObjectShape({
+            source: record,
+            properties: record.transform(({ $ }) => ({
+                $id: $.val(NowIdShape.from(record)),
+                annotation: $.from('comment').def(''),
+                uuid: $.from('ui_id').def(''),
+            })),
+        })
+
+        // Create the CallExpressionShape for the action/subflow instance
+        const callExpression = new 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() === ACTION_INSTANCE_API_NAME) {
+            identifierPrefix = 'action'
+        } else if (callee.toLowerCase() === 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 =
+            getDirectVariableIdentifier(record.getOriginalSource()) ?? `${identifierPrefix}Instance_${order}` // _${instanceId.slice(0, 8)}`
+
+        // Wrap in VariableStatementShape with isExported: false
+        return {
+            success: true,
+            value: new VariableStatementShape({
+                source: record,
+                variableName,
+                initializer: callExpression,
+                isExported: false,
+            }),
+        }
+    }
+}
+
+export const FlowInstancePlugin = Plugin.create({
+    name: 'FlowInstancePlugin',
+    records: {
+        sys_hub_action_instance_v2: {
+            toShape: buildInstanceToShape({
+                defColumn: ACTION_DEF_COLUMN_NAME,
+                inputsTableName: 'sys_hub_action_input',
+                zippedColumn: 'values',
+                callee: ACTION_INSTANCE_API_NAME,
+            }),
+        },
+        sys_hub_sub_flow_instance_v2: {
+            toShape: buildInstanceToShape({
+                defColumn: 'subflow',
+                inputsTableName: 'sys_hub_flow_input',
+                zippedColumn: 'subflow_inputs',
+                callee: SUBFLOW_INSTANCE_API_NAME,
+            }),
+        },
+    },
+    shapes: [
+        {
+            // Look for FDInstanceShape and return instance records as needed for Flow plugin
+            shape: ActionSubflowInstanceShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { factory, transform, diagnostics, logger }) {
+                const instanceType = callExpression.getInstanceType()
+
+                // Shortcut for unsupported instance types
+                if (instanceType !== ACTION_INSTANCE_API_NAME && instanceType !== 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: Record | undefined
+
+                if (instanceType === 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 === 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: string,
+    scriptActive: boolean | undefined,
+    script: { [key: string]: { scriptActive: boolean; script: string } } | undefined,
+    source: Record
+): FDInlineScriptCallShape | undefined {
+    if (scriptActive === true && script && script[fieldName]?.script) {
+        const scriptContent = script[fieldName].script
+
+        return new 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,
+}: {
+    zippedInputs: string
+    definitionInputs: Record[] | undefined
+    record: Record
+    logger: Logger
+}): ObjectShape | undefined {
+    if (!zippedInputs) {
+        return undefined
+    }
+
+    const props: { [key: string]: unknown } = {}
+
+    try {
+        const unzipped = gunzipSync(Buffer.from(zippedInputs, 'base64')).toString()
+        const values: Array<{
+            name: string
+            value: unknown
+            scriptActive?: boolean
+            script?: { [key: string]: { scriptActive: boolean; script: string } }
+            parameter: { type: string; attributes: { [key: string]: unknown } }
+        }> = 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 ? 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 (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 as string, 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 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,
+}: {
+    actionDef: Record | StringShape | undefined
+    inputs: ObjectShape
+    sysId: NowIdShape
+    annotation: string | undefined
+    uuid: string | undefined
+    factory: Factory
+    source: Source
+    transform: Transform
+    logger: Logger
+}): Promise<Record | undefined> {
+    const values = actionDef ? await prepareActionInstanceValueJson(inputs, actionDef, transform, logger) : undefined
+    const actionDefRecord = actionDef instanceof 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 : sysIdToUuid(record.getId().getValue())
+    return record.merge({ ui_id: instanceUUID })
+}
+
+async function buildSubflowInstance({
+    subflowDef,
+    inputs,
+    sysId,
+    annotation,
+    factory,
+    uuid,
+    source,
+    transform,
+}: {
+    subflowDef: Record | StringShape | undefined
+    inputs: ObjectShape
+    sysId: NowIdShape
+    annotation: string | undefined
+    factory: Factory
+    uuid: string | undefined
+    source: Source
+    transform: Transform
+}): Promise<Record | undefined> {
+    const values = subflowDef ? await prepareSubflowInstanceValueJson(inputs, subflowDef, transform) : undefined
+
+    const subflowDefRecord = subflowDef instanceof Record ? subflowDef : undefined
+    const instanceProps = inputs.transform(({ $ }) => ({
+        order: $.val(1 as number),
+        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 : 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: ObjectShape,
+    _transform: Transform
+): Promise<Array<[string, unknown]>> {
+    const entries = instanceInputs.entries({ resolve: false })
+    const results: [string, unknown][] = []
+
+    for (const [key, shape] of entries) {
+        // Handle wfa.inlineScript() calls - they should already be FDInlineScriptCallShape after plugin processing
+        if (shape instanceof FDInlineScriptCallShape) {
+            const scriptContent = shape.getValue()
+            if (typeof scriptContent === 'string') {
+                // Wrap the script content in a TemplateExpressionShape
+                const templateShape = new TemplateExpressionShape({
+                    source: shape,
+                    literalText: scriptContent,
+                })
+                // Create InlineScriptShape for Flow Designer serialization
+                const inlineScript = new 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: string,
+    value: unknown,
+    parentDef: Record,
+    inputTableName: string,
+    logger?: Logger
+): { value: unknown; internalType: unknown } {
+    return _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: unknown): boolean {
+    return typeof value === 'object' && value !== null && (value as { scriptActive?: boolean }).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: string,
+    objShape: ObjectShape,
+    options?: {
+        type?: unknown
+        actionDefRecord?: Record
+        inputTableName?: string
+        logger?: Logger
+    }
+): unknown {
+    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: unknown = primitiveValue
+    let finalType: unknown = 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: Record, inputName: string): unknown | undefined {
+    // Get attributes and check if hidden
+    const attributes = inputDef.get('attributes')?.ifString()?.getValue()
+    const visibleAttr = attributes ? getAttributeValue(attributes, 'visible') : undefined
+    const visibleInFdAttr = attributes ? 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: { visible?: boolean; visible_in_fd?: boolean } = {}
+        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: ObjectShape | undefined,
+    actionDef: Record | StringShape,
+    transform: Transform,
+    logger: Logger
+) {
+    const actionDefRecord = actionDef.isRecord() ? actionDef.as(Record) : undefined
+    if (!instanceInputs) {
+        return []
+    }
+    const isActionDefString = actionDef instanceof 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 ObjectShape({
+        source: instanceInputs.getSource(),
+        properties: Object.fromEntries(mergedResults),
+    })
+
+    const result: unknown[] = []
+
+    // 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: ObjectShape,
+    subflowDef: Record | StringShape,
+    transform: 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 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: unknown; internalType: unknown; children?: unknown[] } = {
+                value: primitiveValue,
+                internalType: undefined,
+            }
+            if (subflowDef.isRecord()) {
+                resolvedValue = resolveComplexInput(key, primitiveValue, subflowDef.as(Record), 'sys_hub_flow_input')
+            }
+
+            const result: globalThis.Record<string, unknown> = {
+                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: Shape): shape is PropertyAccessShape | TemplateExpressionShape | IdentifierShape {
+    return (
+        shape instanceof PropertyAccessShape ||
+        shape instanceof TemplateExpressionShape ||
+        shape instanceof 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: ObjectShape, transform: Transform): Promise<unknown> {
+    const entries = shape.entries({ resolve: false })
+    const resolvedObject: { [key: string]: unknown } = {}
+
+    for (const [key, valueShape] of entries) {
+        if (isDataPillShape(valueShape)) {
+            // Resolve data pill shapes
+            resolvedObject[key] = await 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: unknown[] = []
+
+            for (const element of elements) {
+                if (isDataPillShape(element)) {
+                    resolvedArray.push(await 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 ObjectShape({
+                        source: element.getSource(),
+                        properties: { temp: element },
+                    })
+                    const resolved = await resolveObjectShapeRecursively(tempShape, transform)
+                    resolvedArray.push((resolved as { temp: unknown }).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: Shape, resolvedValue: unknown, source: Source): unknown {
+    if (shape.is(ApprovalRulesShape)) {
+        return new ApprovalRulesShape({
+            source,
+            value: resolvedValue as ApprovalRulesType,
+        }).toString()
+    } else if (shape.is(TemplateValueShape)) {
+        return new TemplateValueShape({
+            source,
+            value: resolvedValue as globalThis.Record<string, unknown>,
+        }).toString()
+    } else if (shape.is(DurationShape)) {
+        return new DurationShape({
+            source,
+            value: resolvedValue as Duration,
+        }).toString()
+    } else if (shape.is(ApprovalDueDateShape)) {
+        return new ApprovalDueDateShape({
+            source,
+            value: resolvedValue as ApprovalDueDateType,
+        }).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: ObjectShape, transform: Transform) {
+    const entries = instanceInputs.entries({ resolve: false })
+    const results: [string, unknown][] = []
+
+    for (const [key, shape] of entries) {
+        if (shape && isDataPillShape(shape)) {
+            const resolvedValue = await resolveDataPillShape(shape, transform)
+            results.push([key, resolvedValue])
+        } else if (shape.is(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(DurationShape)
+            const durationValue = durationShape.getDuration()
+            const wrappedValue = wrapSpecialShape(shape, durationValue, instanceInputs.getSource())
+            results.push([key, wrappedValue])
+        } else if (shape.isObject() || shape.is(TemplateValueShape)) {
+            const objShape = shape.is(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: Shape, transform: Transform): Promise<unknown[]> {
+    const elements = arrayShape.asArray().getElements(false)
+    const resolvedArray: unknown[] = []
+
+    for (const element of elements) {
+        if (isDataPillShape(element)) {
+            resolvedArray.push(await 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
+}