Fix initial code step functionInput (#18002)

At code step creation

## before
<img width="623" height="816" alt="image"
src="https://github.com/user-attachments/assets/0aed5ed8-8d56-4988-9d31-fe80942191bb"
/>

## after
<img width="627" height="528" alt="image"
src="https://github.com/user-attachments/assets/9e2a5cb9-7480-4734-8e41-25b45edcec07"
/>

packages/twenty-shared/src/workflow/index.ts

@@ -67,6 +67,12 @@ export { workflowRunStatusSchema } from './schemas/workflow-run-status-schema';
 export { workflowRunStepStatusSchema } from './schemas/workflow-run-step-status-schema';
 export { workflowTriggerSchema } from './schemas/workflow-trigger-schema';
 export type { EmailRecipients } from './types/EmailRecipients';
+export type { FunctionInput } from './types/FunctionInput';
+export type {
+  InputSchemaPropertyType,
+  InputSchemaProperty,
+  InputSchema,
+} from './types/InputSchema';
 export type { StepIfElseBranch } from './types/StepIfElseBranch';
 export type { BodyType } from './types/workflowHttpRequestStep';
 export type {
@@ -76,6 +82,7 @@ export type {
 export { StepStatus } from './types/WorkflowRunStateStepInfos';
 export { canObjectBeManagedByWorkflow } from './utils/canObjectBeManagedByWorkflow';
 export { extractRawVariableNamePart } from './utils/extractRawVariableNameParts';
+export { getFunctionInputFromInputSchema } from './utils/getFunctionInputFromInputSchema';
 export { getWorkflowRunContext } from './utils/getWorkflowRunContext';
 export { parseBooleanFromStringValue } from './utils/parseBooleanFromStringValue';
 export { parseDataFromContentType } from './utils/parseDataFromContentType';

packages/twenty-shared/src/workflow/types/FunctionInput.ts

@@ -0,0 +1,5 @@
+export type FunctionInput =
+  | {
+      [name: string]: FunctionInput;
+    }
+  | any;

packages/twenty-shared/src/workflow/types/InputSchema.ts

@@ -0,0 +1,17 @@
+import { type LeafType, type NodeType } from '@/workflow';
+import { type FieldMetadataType } from '@/types';
+
+export type InputSchemaPropertyType = LeafType | NodeType | FieldMetadataType;
+
+export type InputSchemaProperty = {
+  type: InputSchemaPropertyType;
+  enum?: string[];
+  items?: InputSchemaProperty;
+  properties?: Properties;
+};
+
+type Properties = {
+  [name: string]: InputSchemaProperty;
+};
+
+export type InputSchema = InputSchemaProperty[];

packages/twenty-shared/src/workflow/utils/__tests__/getDefaultFunctionInputFromInputSchema.test.ts

@@ -0,0 +1,43 @@
+import { getFunctionInputFromInputSchema, type InputSchema } from '@/workflow';
+
+describe('getDefaultFunctionInputFromInputSchema', () => {
+  it('should init function input properly', () => {
+    const inputSchema = [
+      {
+        type: 'object',
+        properties: {
+          a: {
+            type: 'string',
+          },
+          b: {
+            type: 'number',
+          },
+          c: {
+            type: 'array',
+            items: { type: 'string' },
+          },
+          d: {
+            type: 'object',
+            properties: {
+              da: { type: 'string', enum: ['my', 'enum'] },
+              db: { type: 'number' },
+            },
+          },
+          e: { type: 'object' },
+        },
+      },
+    ] as InputSchema;
+    const expectedResult = [
+      {
+        a: null,
+        b: null,
+        c: [],
+        d: { da: 'my', db: null },
+        e: {},
+      },
+    ];
+    expect(getFunctionInputFromInputSchema(inputSchema)).toEqual(
+      expectedResult,
+    );
+  });
+});

packages/twenty-shared/src/workflow/utils/getFunctionInputFromInputSchema.ts

@@ -0,0 +1,27 @@
+import { type InputSchema, type FunctionInput } from '@/workflow';
+import { type InputJsonSchema } from '@/logic-function';
+import { isDefined } from '@/utils';
+
+export const getFunctionInputFromInputSchema = (
+  inputSchema: InputSchema | InputJsonSchema[],
+): FunctionInput => {
+  return inputSchema.map((param) => {
+    if (
+      isDefined(param.type) &&
+      ['string', 'number', 'boolean'].includes(param.type)
+    ) {
+      return param.enum && param.enum.length > 0 ? param.enum[0] : null;
+    } else if (param.type === 'object') {
+      const result: FunctionInput = {};
+      if (isDefined(param.properties)) {
+        Object.entries(param.properties).forEach(([key, val]) => {
+          result[key] = getFunctionInputFromInputSchema([val])[0];
+        });
+      }
+      return result;
+    } else if (param.type === 'array' && isDefined(param.items)) {
+      return [];
+    }
+    return null;
+  });
+};