Skip to content
Psyncopate TIBCO Modernization Suite Docs

Mapping Documents Generator

TIBCO Projects often contain complex process flows, numerous activities, and intricate field mappings. Understanding these elements is crucial for planning and executing a successful migration to modern architectures.

The Mapping Documents Generator automates the creation of comprehensive mapping and requirements documentation for TIBCO® projects. It produces structured outputs across Use Cases, Processes, Transitions, Field Mappings, and Mapping References, with built‑in complexity metrics to inform and streamline your migration planning.

Post-Processing Steps

  1. Click the Mapping documents generator icon (labeled Mapping Docs/Documents) to view results when processing completes.

    Mapping Docs Icon

  2. Review Columns

    • Mapper ID: Unique accelerator-level identifier.
    • Complexity: Overall complexity of the project, calculated based on the highest complexity level among all processes.
    • Mapping Count: Total number of detected mappings across all processes.
    • Transition Count : Total number of detected transitions across all processes.

  3. Actions

    • Download: Requests download of all CSV files as a ZIP archive.
    • View:
      • Click the View icon to open the Mapping Documents viewer.
      • The documents are organized into sections, each focusing on specific aspects of the project such as use cases, processes, transitions, field mappings, and mapping references.
  • Generate Prompts:
    • This feature is currently in development and will be available in future releases.
    • Once available, it will allow users to generate a structured bundle of use case artifacts and LLM-ready prompt templates to accelerate development tasks using large language models (LLMs).
  • Orchestration Generation:
    • Select one or more use case(s) and click the Orchestration Generation icon to create orchestration logic and deployable microservices.
    • You will be prompted to select the target programming language for orchestration generation: Java, Python, or C#. Currently, only Java is supported. Support for Python and C# will be added in future releases.
    • Clicking Generate Orchestration creates a new orchestration job, which is displayed in the Orchestrations tab. For next steps, refer to the Orchestrator documentation.

Complexity Calculation

  1. Click the Calculate Complexity icon to launch the threshold editor.

  2. You will see the following columns:

    • # – Sequence number
    • Components – e.g., JMS, JDBC, Mapping count, Transition count, etc.
    • Small, Medium, Large – Upper limits for each category (Small < Medium < Large). Values above Large default to X-Large.

  3. Edit Thresholds

    • Click Edit to enable in-line changes.
    • Adjust values while maintaining the required order.
    • Add new components using the Add button.
    • Remove unneeded components via the trash icon.
    • Use Reset to restore default or last saved settings.

  4. Manage Templates

    • Use the Saved Templates dropdown to apply previously stored configurations (components not present in the current project are omitted).

    • Click Submit to apply updated thresholds. A pop-up will prompt for a template name.

      • If you provide a unique name and click Save, the thresholds will be applied and saved as a new template.
      • If you click Cancel, the thresholds will still be applied to the current project, but will not be saved as a template.
      • To discard all unsaved changes and revert to the last saved or default state, click the ‘X’ icon in the popup.

    • You can download the current complexity configuration as a CSV file using the download icon.

  5. Apply & Recalculate

    On Submit, the tool recalculates the complexity at the Use Case level and updates the overall Project Complexity accordingly.

    • Each Use Case includes a starter process and all of its related sub-processes. The tool consolidates all components used across these processes and evaluates their counts against the defined complexity thresholds.
    • The Use Case complexity is then determined by identifying the highest applicable threshold based on those consolidated component counts.
    • For example, if a Use Case includes 24 JMS components (with a Small threshold of 25) and 10 JDBC components (with a Large threshold of 10), the Use Case is classified as Large, since the JDBC count hits the highest configured threshold.
    • Once all Use Cases have been evaluated, the Project Complexity is calculated by averaging the component usage across all Use Cases and then applying the same threshold logic to determine the overall level (e.g., Small, Medium, Large, X-Large).

Output Details

Mapping documents are categorized into sections, each focusing on specific aspects of the input TIBCO project such as transition flows, activity types, field mappings, and use cases. This structure allows users to quickly locate relevant information.

Use Cases

Displays all use cases in the project, each built from a starter (main) process and its associated sub-processes. This section consolidates complexity, mappings, transitions, and component usage to help teams understand integration scope and technical effort.

Clicking a use case name opens a flow diagram that visualizes the process structure and components involved. Columns include Use Case, Complexity, Mapping Count, Transition Count, and component names with their respective counts.

Processes

Lists all individual process files in the project along with activity counts, mappings, transitions, and component usage. This section helps teams inspect functional building blocks at the process level.

Each process can be expanded to reveal activities. Selected activities can be submitted to Mapping Jobs for traceability and downstream analysis. Visual flow diagrams are available for each process to support deeper understanding. Columns include Use Case, Process, Activity Count, Mapping Count, Transition Count, and Component names with their respective counts.

Transitions

Displays all transition flows between activities in each process. It outlines how control moves through the logic, including groupings and conditional paths, offering visibility into execution flow and decision logic.

Columns include Use Case, Process, Group Name, Transition From, Transition To, Is Starter flag, Condition Type, and Condition.

Field Mappings

Lists the field mappings of each activity in the process files, including input and binding nodes, group names, and conditions associated with each activity, along with a condition group implemented to identify the order of those fields easily. This section provides a detailed view of the nodes and their mappings within the activities.

Columns include: Use Case name, process name, group name, activity name, input & binding nodes, and conditional parameters (condition and condition group).

Mapping References

Captures how variables and activities are referenced within process logic. It lists each instance where an activity refers to another activity’s output, input bindings, or transition conditions, enabling users to trace data and logic dependencies.

Columns include: Use Case, Process, Activity Name, Activity Type, Field Name, Reference Type, Reference Name, Reference Field Name, and Expression.

Mapping Jobs

Displays all mapping jobs created by selecting activities from process files. Each job records the details of selected activities, including their targets and data sources, and serves as a reference point for tracking field-level mappings.

Users can download the mapping job output as a CSV file. Each file includes columns such as Process File Location, Process File Name, Activity Name, Target, Sources for deeper analysis and reporting.

Description of Columns

  • Process: Name of the process being analyzed. This is the name of the use case too, in only the Use Cases section.
  • Use Case: Name of the use case, which is typically the main process or starter process.
  • Process Location: File path or location of the process.
  • Use Case Location: File path or location of the use case.
  • Complexity: Assessed complexity of the process, calculated based on the thresholds set in the complexity calculation step.
  • Mapping Count: Total number of mappings detected in the process.
  • Transition Count: Total number of transitions detected in the process.
  • Activity Count: Total number of activities in the process.
  • Group Name: The group name as specified in the process, if available.
  • Activity Name: Name of the activity in the process.
  • Activity Type: Class name of the activity as defined in the project.
  • Transition From: Specifies the starting activity of each transition in the process flow.
  • Transition To: Specifies the ending activity of each transition in the process flow.
  • Is Starter: Indicates if the activity is a starter activity (true/false).
  • Condition Type: Type of condition applied to a transition (e.g., error, always, etc.).
  • Condition: The specific condition applied to a transition.
  • Input Node: The input node for the activity, which is the source of data for that activity.
  • Binding Node: The binding node for the activity, which is the target for data output.
  • Condition Group: The group of conditions assigned to the activity to identify the order of fields.
  • Field Name: Name of the field being mapped in the activity.
  • Reference Type: Type of reference used in the activity (e.g., Activity - InputBindings, etc.).
  • Reference Name: Name of the reference used in the activity.
  • Reference Field Name: Name of the field in the reference.
  • Expression: Expression used in the activity.

The Mapping Documents Generator analyzes all the processes in the input project, capturing key details such as use cases, transitions, activity types, and field mappings, and identifies process flows, dependencies, and conditional logic. It calculates process complexity, allowing for dynamic threshold adjustments. The resulting documentation provides a comprehensive overview of the project, facilitating migration planning and execution.



TIBCO® is a registered trademark of Cloud Software Group, Inc. and/or its subsidiaries in the United States and/or other countries. All other product names, logos, and brands are the property of their respective owners.