Anthony-Jhoiro commented 1 year ago

Release Management

To make the Selflow project usable by most, a string release system to track changes is required.

This repository is a monorepo that contains the code of multiple applications, plugins, libraries, and core libraries. They should share the same release cycle because they are all part of the Selflow ecosystem, and it can help track the updates.

This issue is still a draft, but I am already open to your feedbacks

Requirements:

These requirements can be subject to change if better ideas are suggested !

Do not use a Gitflow-style flow. A Trunk-based flow is more appropriate as it skips the need for an intermediate branch that could not be cleaned. The requirements I have for this release system:
Follow the Gitmoji convention. The Gitmoji allows more precision on what changes are made compared to the karma convention. This will make generating Changelog easier.
Create a release following the semver convention.
Do not trigger any major, minor, or patch release unless the main applications (e.g., the Selflow lib engine) are updated. Main changes can be tracked using nx tags with a scope:core on the main projects/libs.
Each merge pull request should have its release (maybe using pre-release for non-core-elements).

I am, of course, open to suggestions!

Draft ideas:

Any package deployment or automation related to release can be managed using a "release" NX target.
semantic-release seems too limited to fit these needs (https://github.com/selflow/selflow/issues/53#issuecomment-1793392398)
By migrating the project to NX 17, we have access to 2 commands: nx show projects --affected and nx show project [project-name] --json, which can be used to know if the changes in the release affect main projects. If you are unfamiliar with nx, you can use this command yarn -s nx show projects --affected | xargs -I % bash -c "yarn -s nx show project % --json" | jq -n '[ inputs.tags ]'

Tools to test

sylvain-lavazais commented 1 year ago

here an idea to test with:

semantic-release (https://github.com/semantic-release/semantic-release) can define you own release cycle by using some modules that fulfil all steps of a release (https://github.com/semantic-release/semantic-release#release-steps)

for each steps semantic-release provide a bunch of plugins with, for some of them, many configuration possible.

for the step analyzeCommits the plugins commit-analyzer (https://github.com/semantic-release/commit-analyzer) can be set-up with configurations on scope and release kind.

https://github.com/semantic-release/commit-analyzer#releaserules

Therefor, it should be possible to accomplish a solution that fit your need.

Anthony-Jhoiro commented 1 year ago

Thanks for your answer @lavazais-sylvain! I did a small POC to test this. This was my process:

upgrade project to nx 17 to have access to the commands nx show projects --affected and nx show project [project-name] --json. Both commands allows to get all projects affected in a release and their associated tags.
Create a semantic-release plugin with a analyzeCommits export that uses the semantic-release-gitmoji to support gitmojis and know if a release is needed.
Use the previous commands to know is a project with the tag scope:core has been updated. If yes, do a major, minor or patch release. Otherwise, do a prerelease.

In paper, this should be working fine, this is the resulting code

.release.js

```js //..... module.exports = { branches: ["master", "main"], plugins: [ [ "./custom-plugin.js", { releaseRules: { major: [":boom:"], minor: [":sparkles:"], patch: [ ":bug:", ":ambulance:", ":lock:", ":lipstick:", ":zap:", ":globe_with_meridians:", ":alien:", ":wheelchair:", ":loud_sound:", ":mute:", ":children_crossing:", ":speech_balloon:", ":iphone:", ":pencil2:", ":bento:", ":green_apple:", ":green_heart:", ], }, }, ], //.... ], }; ```

./custom-plugin.js

```js const {analyzeCommits: gitmojiAnalyzeCommits} = require("semantic-release-gitmoji"); const {spawnSync} = require('child_process'); async function analyzeCommits(pluginConfig, context) { const {commits, logger} = context; /** * @type {string} */ const releaseType = gitmojiAnalyzeCommits(pluginConfig, context); if (!releaseType) { logger.log("No release is needed") return null; } const {stdout} = await spawnSync('yarn -s nx show projects --affected | xargs -I % bash -c "yarn -s nx show project % --json" | jq -n \'[ inputs.tags ]\'', { shell: "/bin/bash", env: { NX_HEAD: commits[0].commit.long, NX_BASE: commits[commits.length - 1].commit.long, } }) const tags = JSON.parse(stdout.toString()).flat() const isCore = tags.includes("scope:core") if (isCore) { logger.log(`Core Release ${releaseType}`) return releaseType } return "prerelease"; } module.exports = { analyzeCommits } ```

The resulting issue is that semantic-release restrict commitAnalyzer plugins to only return major, minor, and patch release and not prerelease... So it returns an error

I didn't try with a scope and the karma-commit convention yet but the limitation is hard-coded in the semantic-release code, so it does not seem possible to use it to handle pre-release this way. It allows pre-release but only for branches wich I don't think is well suited for the problem

selflow / selflow