Hi @Shaun17501594
@duraisankar explanation is correct. However, I would like to clarify a few points regarding ruleset versioning, Standalone vs. Library mode, and GitHub version control, based on our implementation approach.
1. Ruleset Management
We maintain all our custom DX components under a single ruleset, DXComponents, using different ruleset versions. This makes it easier to manage and track all our custom components in one ruleset.
For example:
We publish our organization’s custom components to version 01-01-02.
2. Standalone vs. Library Mode
From Pega Constellation '25 onwards, we have two publishing approaches: Standalone and Library mode.
Standalone Mode
In Standalone mode, the component is published to the ruleset version configured in task.config.json.
For example:
-
Initially, we publish an Email component to DXComponents:01-01-02.
-
Later, we update the component and publish it to DXComponents:01-01-03.
-
In our observed behavior, the component is then available under 01-01-03, rather than retaining an independently available copy under 01-01-02.
This is an important consideration when managing component versions.
Library Mode
Library mode provides a different approach to managing and versioning components.
However, one important point is that Pega ruleset versioning and source-code versioning are different concepts.
If we change a component’s version and modify its source code, changing the ruleset version alone does not automatically restore the previous React/TypeScript implementation.
For this, we need proper source-code version control.
3. Why Do We Use GitHub?
GitHub is a cloud-hosted Git repository used to store, manage, track, and collaborate on our component source code.
Why is GitHub important?
Suppose a developer creates multiple custom DX components and stores the source code only on their local machine.
-
Scenario 1 — System Crash: If the developer’s laptop crashes or the data is lost, we may lose the entire source code if no backup exists.
-
Scenario 2 — Employee Leaves: If a developer leaves the organization and the code is available only on their local machine, other team members may not have access to it.
-
Scenario 3 — Team Collaboration: If multiple developers work on the same component, managing changes becomes difficult without a shared repository.
-
Scenario 4 — Access Control: In a private GitHub repository, only authorized users can access the code. Repository permissions determine who can view, contribute, or modify it.
By maintaining our source code in GitHub, we ensure that the code is centrally available, version-controlled, and not dependent on any individual developer’s local machine.
It also serves as a remote backup of the code that has been committed and pushed to the repository.
A simple example of GitHub version control:
Suppose we develop an Email component.
Version 1:
Version 2:
Version 3:
- We introduce another enhancement, but it causes an issue.
If we want the previous working implementation, we can retrieve Version 2 from GitHub using its commit history or release tag.
We can then rebuild, test, and republish that version to the appropriate Pega ruleset.
The main advantage is that we do not need to maintain separate local copies of every version. GitHub maintains the committed history, allowing us to retrieve previous implementations whenever needed.
4. GitHub vs. Pega Ruleset Versioning
The key difference is:
-
GitHub: Manages and maintains the history of our React/TypeScript source code, supports team collaboration, and provides centralized storage.
-
Pega Ruleset: Manages the published component artifacts within the Pega application.
These are two different versioning mechanisms, and both are important.
5. Migration to Higher Environments
Once the components are published and validated in Development, we can package the required rulesets into a RAP and deploy them to higher environments using the standard Pega deployment process.
The GitHub repository remains our source-code repository, while Pega manages the published components.
We do not need to clone the GitHub repository or rebuild the components separately in every higher environment when deploying the packaged artifacts.
I hope this provides additional clarity on component publishing, ruleset management, GitHub version control, and migration to higher environments.