// Simple
Output = {
  result: "success",
  count: 42
};

// Using input variables
Output = {
  fullName: `${input.firstName} ${input.lastName}`,
  isAdult: input.age >= 18
};

// lodash — group, sort, filter arrays
const grouped = _.groupBy(input.items, 'category');
Output = { grouped };

// moment — parse and format dates
Output = {
  formatted: moment(input.date).format('YYYY-MM-DD'),
  daysAgo: moment().diff(moment(input.date), 'days')
};

• Complex data transformation or format conversion
• Mathematical or date calculations
• Parsing nested JSON structures
• Data validation, deduplication, or standardisation
• Conditional logic too complex for a Filter
• Combining or restructuring multiple fields

• Making HTTP requests to external APIs (not supported)
• Reading or writing files (not supported)
• Async operations (no async/await or Promises)
• Simple field mapping (use the standard field mapper)
• Logic already covered by Filter or Path nodes

1. Open your konnector in the Konnectify editor.
2. Click the + button on the node after which you want custom logic.
3. Select Code Block from the node type menu.
4. The Code Block node appears on the canvas and the configuration sidebar opens automatically.

1. In the Input Variables section, click Add Variable.
2. Enter a Key — a descriptive JavaScript identifier (e.g., ticketData, customerEmail).
3. Click the Value field and use the field mapper to select a field from an upstream node, or type a literal value.
4. Repeat for each piece of data your code needs.

1. In the code editor, access your input variables via input.variableName.
2. Implement your logic using JavaScript ES6+.
3. Use _ for lodash operations or moment for date operations if needed.
4. Assign your results to Output = { ... } — this is mandatory.

1. Click the Test Code button at the bottom of the panel.
2. The Test Input Modal opens — enter test values for each input variable.
3. Click Run to execute the code on the server.
4. Review the result: Success shows the Output value, execution time, and memory usage. Error shows the error message and stack trace.
5. Fix any errors and re-test until the test passes.

1. Once the test succeeds, the Continue button becomes enabled.
2. Click Continue to save the code, input variable mappings, and the output schema.
3. The output schema is now available for downstream nodes to reference via field mapping.

1. Click the + button below your Code Block node.
2. Add the next action node in your workflow.
3. When configuring field mapping for the next action, the fields from your Code Block's Output object appear as available fields — map them just like any other field.

Combine first and last name fields, normalise the priority to lowercase, and generate a display label for a Slack message.

const priority = input.ticketPriority.toLowerCase();
const isUrgent = ['urgent', 'high'].includes(priority);

Output = {
  fullName: `${input.firstName} ${input.lastName}`,
  priority,
  isUrgent,
  label: isUrgent ? '? Urgent' : '? Normal'
};

An array of order items needs to be grouped by category, with a count per category and the total order value — all for a downstream summary notification.

const grouped = _.groupBy(input.items, 'category');
const categoryCounts = _.mapValues(grouped, items => items.length);
const totalValue = _.sumBy(input.items, 'price');

Output = {
  grouped,
  categoryCounts,
  totalValue,
  itemCount: input.items.length
};

A ticket was created at an ISO timestamp. Format it for display, calculate how many days it has been open, and flag it if it's been open more than 7 days.

const created = moment(input.createdAt);
const daysOpen = moment().diff(created, 'days');
const isStale = daysOpen > 7;

Output = {
  formattedDate: created.format('DD MMM YYYY, HH:mm'),
  daysOpen,
  isStale,
  staleLabel: isStale ? `Open ${daysOpen} days — needs attention` : 'On track'
};

When parsing raw API responses that may contain malformed data, wrapping the logic in try-catch ensures the workflow continues even if processing fails — with the error captured in the output for debugging.

let Output;
try {
  const raw = JSON.parse(input.rawPayload);
  const items = raw.data.items.filter(i => i.active);
  Output = {
    success: true,
    items,
    count: items.length
  };
} catch (error) {
  Output = {
    success: false,
    error: error.message,
    items: [],
    count: 0
  };
}

The Test Input Modal opens. Enter realistic test values for each input variable — values that represent what the workflow will actually receive at runtime.

Success shows the Output value, execution time, and memory usage. Error shows the error message and stack trace — use this to pinpoint the issue in your code.

Re-run the test with edge case inputs — null values, empty strings, unexpected types, or very large numbers. Make sure your code handles these gracefully, ideally with try-catch blocks.

After a successful test, review the Output object. Confirm it contains all the fields downstream nodes will need and that they have the correct types (string, number, boolean, object, array).

Once the test succeeds and you're happy with the Output structure, click Continue to save the code, variable mappings, and the generated output schema.