@payfit/nx-core 4.42.3 → 4.42.4-ephemeral-bundle-nx-core-7fdfd20.0

package/README.md

@@ -0,0 +1,201 @@
+# @payfit/nx-core
+
+A Nx plugin that simplifies Docker image and Helm chart packaging and releases using Nx's versionActions feature.
+
+## Features
+
+- Automated Docker image building and publishing
+- Helm chart packaging and versioning
+- AWS Lambda function packaging and deployment
+- Transparent version management through Nx's versionActions
+- Seamless integration with your Nx workspace
+- Auto setup using init generator to update your repository at plugin installation
+
+## Prerequisites
+
+To make sure we are able to cache packages correctly, monorepo should be using yarn v4
+
+## Installation
+
+```shell
+npx nx add @payfit/nx-core
+```
+
+This command will:
+
+- Install the package as a dev dependency
+- Run the [init generator](./src/generators/init) to set up the necessary configuration
+- Update your workspace configuration automatically
+
+### Init generator
+
+Using the above command will setup your repo with the default recommended configuration. You are free to edit this configuration to your needs.
+
+In the `nx.json` file:
+
+```
+  "release": {
+    "projectsRelationship": "independent",
+    "projects": ["*"],
+    "releaseTagPattern": "{projectName}-{version}",
+    "changelog": {
+      "projectChangelogs": {
+      "createRelease": "github",
+      "file": false,
+      "git": {
+        "commit": false,
+        "tag": true
+      }
+    },
+    "automaticFromRef": true
+    },
+    "version": {
+      "useLegacyVersioning": false,
+      "currentVersionResolver": "git-tag",
+      "fallbackCurrentVersionResolver": "disk",
+      "specifierSource": "conventional-commits",
+      "manifestRootsToUpdate": ["{workspaceRoot}/dist/{projectRoot}"],
+      "preserveLocalDependencyProtocols": false
+    }
+  },
+  "plugins": ["@payfit/nx-core"]
+  "targetDefaults": [
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "{workspaceRoot}/dist/{projectRoot}",
+      }
+    }
+  ]
+```
+
+It will also generate the CircleCI config file & Teleport file needed.
+
+## Usage
+
+### Docker Image Release
+
+The plugin automatically handles:
+
+- Building Docker images
+- Tagging with appropriate versions
+- Publishing to your container registry
+
+### Helm Chart Release
+
+The plugin manages:
+
+- Chart version updates
+- Chart packaging
+- Chart publishing
+- Automatic image tag patching in values.yaml files
+
+#### Image Tag Patching Behavior
+
+When releasing a new version, the plugin automatically updates Docker image tags in your Helm chart's `values.yaml` file. The patching behavior handles three scenarios:
+
+1. **Dependencies Only**: If your `values.yaml` contains service entries that match the dependencies in your `Chart.yaml`, the plugin will update the image tags for these services.
+
+2. **Global Tag Only**: If your `values.yaml` contains a global image tag (at `image.tag`), the plugin will update this tag with the new version.
+
+3. **Both Dependencies and Global Tag**: If both dependency-specific tags and a global tag are present, the plugin will update all of them to maintain consistency.
+
+This ensures that all relevant image tags are updated to the new version during the release process, regardless of your Helm chart's structure.
+
+### Lambda Function Release
+
+The plugin automates the process of packaging and deploying AWS Lambda functions:
+
+- Creating a zip archive from your Lambda function code
+- Uploading the archive to an S3 bucket
+- Creating an empty OCI artifact and pushing it to ECR for versioning
+
+#### Lambda Configuration Parameters
+
+When using Lambda functions, you can configure the following parameters in your project's `project.json` file:
+
+```json
+{
+  "metadata": {
+    "lambdaRegistry": "your-lambda-registry",
+    "lambdaBucket": "your-lambda-bucket"
+  }
+}
+```
+
+These fields are used to:
+
+- `lambdaRegistry`: the ECR repository name for Lambda function artifacts (this is used to create an empty OCI artifact for versioning)
+- `lambdaBucket`: the S3 bucket where Lambda function zip archives are stored
+
+If `lambdaBucket` is not specified, the plugin will fall back to the default bucket: `payfit-shared-lambda-artifacts`.
+
+#### Lambda Detection
+
+The plugin automatically detects Lambda functions by looking for a `lambdaRegistry` metadata in your project root. When this metadata is present, the plugin will configure the necessary targets for packaging and deploying your Lambda function.
+
+## Configuration
+
+The plugin uses Nx's versionActions to handle versioning transparently. The init generator will set up the required configuration automatically.
+
+You'll need to add the following metadata to your project's `project.json` file:
+
+```json
+{
+  "metadata": {
+    "ecrRegistry": "your-app-name",
+    "chartRegistry": "your-chart-registry",
+    "ociEcrRegistry": "your-app-name",
+    "helmChartFolder": "your-helm-folder",
+    "lambdaRegistry": "your-lambda-registry",
+    "lambdaBucket": "your-lambda-bucket"
+  }
+}
+```
+
+These fields are used to:
+
+- `ecrRegistry`: the ECR repository name for Docker images
+- `chartRegistry`: the Helm chart registry
+- `ociEcrRegistry`: the OCI registry for container images
+- `helmChartFolder`: the folder containing Helm chart files (Chart.yaml, values.yaml, etc.), defaults to `.deploy`
+- `lambdaRegistry`: the ECR repository name for Lambda function artifacts
+- `lambdaBucket`: the S3 bucket where Lambda function zip archives are stored (defaults to `payfit-shared-lambda-artifacts`)
+
+## Automatic Release Target Inference
+
+The plugin automatically infers release targets for your projects based on the presence of deployment files:
+
+1. **Docker Image Release**: If a `Dockerfile` exists in your project root, the plugin will automatically:
+   - Configure Docker image building and publishing
+   - Set up version management for the image
+   - Handle ECR repository integration
+
+2. **Helm Chart Release**: If a `Chart.yaml` exists in your Helm chart folder (defaults to `.deploy/Chart.yaml`), the plugin will automatically:
+   - Configure Helm chart packaging and versioning
+   - Set up chart publishing to your registry
+   - Handle chart dependencies and updates
+
+3. **Lambda Function Release**: If a `.lambda` file exists in your project root, the plugin will automatically:
+   - Configure Lambda function packaging (zip archive creation)
+   - Set up S3 bucket uploading for the Lambda artifact
+   - Create and push an empty OCI artifact to ECR for versioning
+
+The inference of the `nx-release-publish` target is handled through Nx's plugin system, which automatically adds the necessary targets and version actions to your project configuration. You don't need to manually configure these targets.
+
+---
+
+# Debug locally
+
+1. Build everything:
+
+```bash
+npx nx run-many -t build
+```
+
+2. Trigger a new release using the local plugin version:
+
+```bash
+npx nx run @payfit/nx-common-packages:release --dry-run=true
+```
+
+Make sure you pushed a change to your branch to actually trigger a release, otherwise it will say something like `No project to publish`

package/dist/_virtual/rolldown_runtime.js

@@ -0,0 +1,39 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__commonJS', {
+  enumerable: true,
+  get: function () {
+    return __commonJS;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/executors/publisher/docker.js

@@ -0,0 +1,54 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_logger = require('../../utils/common/logger.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_aws_auth = require('../../utils/common/aws-auth.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_github = require('../../utils/common/github.js');
+const require__home_circleci_project_packages_nx_core_src_utils_datadog = require('../../utils/datadog.js');
+const require__home_circleci_project_packages_nx_core_src_utils_docker = require('../../utils/docker.js');
+const node_fs = require_rolldown_runtime.__toESM(require("node:fs"));
+
+//#region src/executors/publisher/docker.ts
+async function publishDocker(options, context, version, projectRoot, isDryRun) {
+	const projectDockerfile = `${projectRoot}/Dockerfile`;
+	if (!node_fs.existsSync(projectDockerfile)) {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.warn(`Dockerfile not found at ${projectDockerfile}, skipping`);
+		return;
+	}
+	if (!options.ecrRegistry) {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.error("Dockerfile detected but No ECR registry provided, add \"ecrRegistry\" to your project.json metadata");
+		return;
+	}
+	const registry = {
+		url: options.isPublicRegistry ? "public.ecr.aws/payfit" : process.env.AWS_ECR_REGISTRY,
+		name: options.isPublicRegistry ? "public.ecr.aws" : process.env.AWS_ECR_REGISTRY
+	};
+	if (isDryRun) {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.box(`Would have published docker image located at ${projectDockerfile} to registry ${options.ecrRegistry} with version ${version} but --dry-run is enabled`);
+		return;
+	}
+	await require__home_circleci_project_packages_nx_core_src_utils_common_aws_auth.checkAwsAuth();
+	await require__home_circleci_project_packages_nx_core_src_utils_common_aws_auth.loginToEcr(registry.name, options.isPublicRegistry);
+	const hasValidCredentials = await require__home_circleci_project_packages_nx_core_src_utils_common_aws_auth.verifyEcrCredentials(registry.name);
+	if (!hasValidCredentials) {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.warn("ECR credentials verification failed. Attempting to login again...");
+		await require__home_circleci_project_packages_nx_core_src_utils_common_aws_auth.loginToEcr(registry.name, options.isPublicRegistry);
+		const retryCredentials = await require__home_circleci_project_packages_nx_core_src_utils_common_aws_auth.verifyEcrCredentials(registry.name);
+		if (!retryCredentials) throw new Error("No valid ECR credentials available for pushing Docker image");
+	}
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.box(`Publishing docker image to ${registry.url}/${options.ecrRegistry} with version ${version}`);
+	const extraTags = !version.includes("ephemeral") && options.extraReleaseTags ? options.extraReleaseTags : [];
+	const sanitizedRepoUrl = await require__home_circleci_project_packages_nx_core_src_utils_common_github.getSanitizedCurrentGitRepoUrl();
+	const commitSha = await require__home_circleci_project_packages_nx_core_src_utils_common_github.getCurrentGitCommitSha();
+	const appName = context.projectName || "unknown-app";
+	try {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.start("Building and pushing docker image");
+		await require__home_circleci_project_packages_nx_core_src_utils_docker.buildAndPushDockerImage(options.ecrRegistry, projectDockerfile, version, sanitizedRepoUrl, commitSha, registry.url, extraTags, appName);
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.success("Docker image built and pushed successfully!");
+		if (!version.includes("ephemeral")) await require__home_circleci_project_packages_nx_core_src_utils_datadog.correlateDeploymentImage(`${registry.url}/${options.ecrRegistry}:${version}`, sanitizedRepoUrl, commitSha);
+	} catch (error) {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.error("Failed to build and push Docker image:", error);
+		throw error;
+	}
+}
+
+//#endregion
+exports.publishDocker = publishDocker;

package/{src → dist}/executors/publisher/executor.d.ts

@@ -1,4 +1,7 @@
-import { ExecutorContext } from '@nx/devkit';
-import { PublisherExecutorOptions, PublisherExecutorSchema } from './schema';
+import { PublisherExecutorOptions, PublisherExecutorSchema } from "./schema.js";
+import { ExecutorContext } from "@nx/devkit";
+
+//#region src/executors/publisher/executor.d.ts
 declare const runExecutor: (options: PublisherExecutorOptions, context: ExecutorContext) => Promise<PublisherExecutorSchema>;
-export default runExecutor;
+//#endregion
+export { runExecutor as default };

package/dist/executors/publisher/executor.js

@@ -0,0 +1,20 @@
+const require__home_circleci_project_packages_nx_core_src_utils_common_nx = require('../../utils/common/nx.js');
+const require__home_circleci_project_packages_nx_core_src_executors_publisher_docker = require('./docker.js');
+const require__home_circleci_project_packages_nx_core_src_executors_publisher_helm = require('./helm.js');
+const require__home_circleci_project_packages_nx_core_src_executors_publisher_lambda = require('./lambda.js');
+
+//#region src/executors/publisher/executor.ts
+const runExecutor = async (options, context) => {
+	const isDryRun = process.env.NX_DRY_RUN === "true" || options.dryRun || false;
+	const projectRoot = context.projectGraph.nodes[context.projectName].data.root;
+	const projectDist = await require__home_circleci_project_packages_nx_core_src_utils_common_nx.getDistForApp(context);
+	const version = require__home_circleci_project_packages_nx_core_src_utils_common_nx.getVersion(context);
+	await require__home_circleci_project_packages_nx_core_src_executors_publisher_docker.publishDocker(options, context, version, projectRoot, isDryRun);
+	await require__home_circleci_project_packages_nx_core_src_executors_publisher_helm.publishHelm(options, context, version, projectRoot, projectDist, isDryRun);
+	await require__home_circleci_project_packages_nx_core_src_executors_publisher_lambda.publishLambda(options, context, version, projectRoot, projectDist, isDryRun);
+	return { success: true };
+};
+var executor_default = runExecutor;
+
+//#endregion
+module.exports = executor_default;

package/dist/executors/publisher/helm.js

@@ -0,0 +1,62 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_logger = require('../../utils/common/logger.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_aws_auth = require('../../utils/common/aws-auth.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_github = require('../../utils/common/github.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_tsh = require('../../utils/common/tsh.js');
+const require__home_circleci_project_packages_nx_core_src_utils_helm = require('../../utils/helm.js');
+const require__home_circleci_project_node_modules__oxc_project_runtime_src_helpers_usingCtx = require('../../node_modules/@oxc-project/runtime/src/helpers/usingCtx.js');
+const node_fs = require_rolldown_runtime.__toESM(require("node:fs"));
+
+//#region src/executors/publisher/helm.ts
+var import_usingCtx = require_rolldown_runtime.__toESM(require__home_circleci_project_node_modules__oxc_project_runtime_src_helpers_usingCtx.require_usingCtx());
+async function publishHelm(options, context, version, projectRoot, projectDist, isDryRun) {
+	try {
+		var _usingCtx = (0, import_usingCtx.default)();
+		const helmChartFolder = options.helmChartFolder || ".deploy";
+		const projectHelmFolder = `${projectRoot}/${helmChartFolder}`;
+		const valuesConfigPath = `${projectHelmFolder}/values.yaml`;
+		const chartConfigPath = `${projectHelmFolder}/Chart.yaml`;
+		const destinationHelmFolder = `${projectDist}/chart/`;
+		const gitBranchName = await require__home_circleci_project_packages_nx_core_src_utils_common_github.getSanitizedCurrentGitBranch();
+		if (!gitBranchName) throw new Error("Unable to get current Git branch");
+		if (!node_fs.existsSync(chartConfigPath)) {
+			require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.warn(`No helm chart found in project ${context.projectName}, searching ${chartConfigPath}, skipping`);
+			return;
+		}
+		if (!options.chartRegistry) {
+			require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.error("Helm chart detected but no chart registry provided, add \"chartRegistry\" to your project.json metadata");
+			return;
+		}
+		if (isDryRun) {
+			require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.box(`Would have published Helm chart located at ${projectHelmFolder} to ${options.ociEcrRegistry ? options.ociEcrRegistry : options.chartRegistry}/${gitBranchName} with version ${version} but --dry-run is enabled`);
+			return;
+		}
+		await require__home_circleci_project_packages_nx_core_src_utils_common_aws_auth.checkAwsAuth();
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.box(`Publishing Helm chart to ${options.chartRegistry}/${gitBranchName} with version ${version}`);
+		const proxyData = _usingCtx.u(await require__home_circleci_project_packages_nx_core_src_utils_common_tsh.getLocalPortForChartMuseum());
+		await proxyData.isReady();
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.start("Building Helm chart");
+		await require__home_circleci_project_packages_nx_core_src_utils_helm.setupTeleportProxyHelmChartFile(projectHelmFolder, proxyData.port);
+		await require__home_circleci_project_packages_nx_core_src_utils_helm.installHelmRepo(projectHelmFolder);
+		await require__home_circleci_project_packages_nx_core_src_utils_helm.patchImageTag(valuesConfigPath, chartConfigPath, version);
+		await require__home_circleci_project_packages_nx_core_src_utils_helm.packageHelm(projectHelmFolder, version, destinationHelmFolder);
+		await require__home_circleci_project_packages_nx_core_src_utils_helm.resetTeleportProxyHelmChartFile(projectHelmFolder, proxyData.port);
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.success("Helm chart packaged!");
+		const chartConfig = await require__home_circleci_project_packages_nx_core_src_utils_helm.getHelmChartFile(projectHelmFolder);
+		const packagedHelmChartName = `${chartConfig.name}-${version}.tgz`;
+		const packagedHelmChartPath = `${destinationHelmFolder}${packagedHelmChartName}`;
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.start("Publishing Helm chart");
+		if (options.ociEcrRegistry) {
+			require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.log(`Publishing Helm chart to OCI registry ${options.ociEcrRegistry}`);
+			await require__home_circleci_project_packages_nx_core_src_utils_helm.pushOciPackagedHelm(packagedHelmChartPath, options.ociEcrRegistry);
+		} else await require__home_circleci_project_packages_nx_core_src_utils_helm.pushPackagedHelm(packagedHelmChartPath, packagedHelmChartName, options.chartRegistry, gitBranchName);
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.success("Helm chart published successfully!");
+	} catch (_) {
+		_usingCtx.e = _;
+	} finally {
+		_usingCtx.d();
+	}
+}
+
+//#endregion
+exports.publishHelm = publishHelm;

package/dist/executors/publisher/lambda.js

@@ -0,0 +1,55 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_logger = require('../../utils/common/logger.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_aws_auth = require('../../utils/common/aws-auth.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_github = require('../../utils/common/github.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_s3 = require('../../utils/common/s3.js');
+const require__home_circleci_project_packages_nx_core_src_utils_lambda_lambda = require('../../utils/lambda/lambda.js');
+const require__home_circleci_project_packages_nx_core_src_utils_lambda_oci = require('../../utils/lambda/oci.js');
+const require__home_circleci_project_packages_nx_core_src_utils_lambda_publish = require('../../utils/lambda/publish.js');
+const path = require_rolldown_runtime.__toESM(require("path"));
+
+//#region src/executors/publisher/lambda.ts
+async function publishLambda(options, context, version, projectRoot, projectDist, isDryRun) {
+	const gitBranchName = await require__home_circleci_project_packages_nx_core_src_utils_common_github.getSanitizedCurrentGitBranch();
+	const repoUrl = await require__home_circleci_project_packages_nx_core_src_utils_common_github.getSanitizedCurrentGitRepoUrl();
+	const repoName = repoUrl.split("/").pop() ?? "unknown-repo";
+	const sanitizedProjectName = context.projectName.replace(/^@payfit\//, "").replace(/[^a-zA-Z0-9-_]/g, "-");
+	const zipName = `${version}.zip`;
+	const zipFileNameS3 = `${options.lambdaBucket}/${repoName}/${sanitizedProjectName}/${zipName}`;
+	if (!gitBranchName) throw new Error("Unable to get current Git branch");
+	if (!options.lambdaRegistry) {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.warn("No lambda registry provided, add \"lambdaRegistry\" to your project.json metadata if this app is a lambda function, otherwise ignore this warning. skipping.");
+		return;
+	}
+	if (!options.lambdaStacks) {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.error("No lambda spacelift stacks provided, add \"lambdaStacks\" to your project.json metadata");
+		return;
+	}
+	if (!options.lambdaFunctions) {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.error("No lambda functions provided, add \"lambdaFunctions\" to your project.json metadata");
+		return;
+	}
+	if (isDryRun) {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.box(`Would have published lambda artefact to S3 ${zipFileNameS3} and ECR ${process.env.AWS_ECR_REGISTRY}/${options.lambdaRegistry}:${version}  but --dry-run is enabled`);
+		return;
+	}
+	await require__home_circleci_project_packages_nx_core_src_utils_common_aws_auth.checkAwsAuth();
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.box(`Publishing the lambda artefact ${zipFileNameS3}`);
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.info(`Zipping ${zipName} from ${projectDist}`);
+	await require__home_circleci_project_packages_nx_core_src_utils_lambda_lambda.createZip(projectDist, zipName);
+	const zipPath = (0, path.join)(projectDist, zipName);
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.info(`Uploading ${zipPath} to S3 at ${zipFileNameS3}`);
+	await require__home_circleci_project_packages_nx_core_src_utils_common_s3.pushToS3(zipPath, zipFileNameS3);
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.success(`Lambda artefact successfully pushed to S3 at ${zipFileNameS3}`);
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.box(`Creating new Lambda version and running smoke tests`);
+	await require__home_circleci_project_packages_nx_core_src_utils_lambda_publish.createLambdaVersion(options.lambdaStacks, options.lambdaFunctions, version);
+	const packageJsonPath = (0, path.join)(projectDist, "package.json");
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.info(`Pushing empty image to ECR ${process.env.AWS_ECR_REGISTRY}/${options.lambdaRegistry}:${version}`);
+	await require__home_circleci_project_packages_nx_core_src_utils_common_aws_auth.loginToEcr(process.env.AWS_ECR_REGISTRY);
+	await require__home_circleci_project_packages_nx_core_src_utils_lambda_oci.pushImageToEcr(options.lambdaRegistry, version, packageJsonPath);
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.success("Lambda artifact successfully pushed to S3!");
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.success(`Lambda version ${version} successfully created and smoke tests passed, you're lambda is ready to be promoted in Kargo !`);
+}
+
+//#endregion
+exports.publishLambda = publishLambda;

package/dist/executors/publisher/schema.d.ts

@@ -0,0 +1,17 @@
+//#region src/executors/publisher/schema.d.ts
+interface PublisherExecutorSchema {} // eslint-disable-line
+interface PublisherExecutorOptions {
+  chartRegistry: string;
+  ecrRegistry: string;
+  ociEcrRegistry?: string;
+  isPublicRegistry?: boolean;
+  helmChartFolder?: string;
+  extraReleaseTags?: string[];
+  dryRun?: boolean;
+  lambdaBucket?: string;
+  lambdaRegistry?: string;
+  lambdaStacks?: string[];
+  lambdaFunctions?: string[];
+}
+//#endregion
+export { PublisherExecutorOptions, PublisherExecutorSchema };

package/{src → dist}/executors/publisher/schema.json

@@ -39,6 +39,23 @@
       "type": "boolean",
       "description": "Whether to run in dry run mode. When true, shows what would be published without actually publishing.",
       "default": false
+    },
+    "lambdaBucket": {
+      "type": "string",
+      "description": "The S3 bucket for lambda",
+      "default": "payfit-shared-lambda-artifacts"
+    },
+    "lambdaRegistry": {
+      "type": "string",
+      "description": "The OCI registry for lambda"
+    },
+    "lambdaStacks": {
+      "type": "array",
+      "description": "The list of stacks to publish the lambda to"
+    },
+    "lambdaFunctions": {
+      "type": "array",
+      "description": "The list of lambda functions inside the workload"
     }
   },
   "required": []

package/dist/executors/release/executor.d.ts

@@ -0,0 +1,7 @@
+import { ReleaseExecutorOptions, ReleaseExecutorSchema } from "./schema.js";
+import { ExecutorContext } from "@nx/devkit";
+
+//#region src/executors/release/executor.d.ts
+declare const runExecutor: (options: ReleaseExecutorOptions, context: ExecutorContext) => Promise<ReleaseExecutorSchema>;
+//#endregion
+export { runExecutor as default };

package/dist/executors/release/executor.js

@@ -0,0 +1,77 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_logger = require('../../utils/common/logger.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_github = require('../../utils/common/github.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_tsh = require('../../utils/common/tsh.js');
+const require__home_circleci_project_packages_nx_core_src_utils_common_circleci = require('../../utils/common/circleci.js');
+const nx_release = require_rolldown_runtime.__toESM(require("nx/release"));
+
+//#region src/executors/release/executor.ts
+const runExecutor = async (options, context) => {
+	const isDryRun = process.env.NX_DRY_RUN === "true" || options.dryRun || false;
+	if (require__home_circleci_project_packages_nx_core_src_utils_common_circleci.isCircleCIRunner()) {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.start("CircleCI runner detected, setting it up!");
+		await require__home_circleci_project_packages_nx_core_src_utils_common_circleci.setupCircleCIRunner();
+		await require__home_circleci_project_packages_nx_core_src_utils_common_tsh.startTbot();
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.success("CircleCI runner setup successfully!");
+	}
+	const branchName = await require__home_circleci_project_packages_nx_core_src_utils_common_github.getSanitizedCurrentGitBranch();
+	const commit = await require__home_circleci_project_packages_nx_core_src_utils_common_github.getCurrentGitCommitSha();
+	const isPreRelease = options?.preRelease != null ? options.preRelease : branchName != "main" && branchName != "master";
+	if (isPreRelease) require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.warn("This is an ephemeral release");
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.start("Calculating new versions");
+	const { projectsVersionData } = await (0, nx_release.releaseVersion)({
+		dryRun: isDryRun,
+		verbose: options.verbose,
+		groups: options.groups && options.groups.length > 0 ? options.groups : void 0,
+		specifier: options.specifier,
+		preid: isPreRelease ? `ephemeral-${branchName.substring(0, 100)}-${commit.substring(0, 7)}` : void 0
+	});
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.success("New versions calculated successfully!");
+	const projectsToPublish = Object.entries(projectsVersionData).map(([projectName, versionData]) => {
+		if (versionData?.newVersion) {
+			require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.info(`Project '${projectName}' will be updated to version ${versionData.newVersion}`);
+			return projectName;
+		}
+		return null;
+	}).filter(Boolean);
+	if (projectsToPublish.length === 0) {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.warn("No project to publish");
+		return { success: true };
+	}
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.start("Generating & pushing changelogs");
+	await (0, nx_release.releaseChangelog)({
+		versionData: projectsVersionData,
+		dryRun: isDryRun,
+		verbose: options.verbose,
+		projects: projectsToPublish,
+		createRelease: isPreRelease ? false : "github",
+		groups: options.groups && options.groups.length > 0 ? options.groups : void 0
+	});
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.success("Generated & pushed changelogs successfully!");
+	if (options.skipPublish) {
+		require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.warn("Skipping publishing step as skipPublish = true");
+		return { success: true };
+	}
+	require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.start("Publishing packages");
+	const publishResults = await (0, nx_release.releasePublish)({
+		projects: projectsToPublish,
+		dryRun: isDryRun,
+		verbose: options.verbose,
+		tag: isPreRelease ? "ephemeral" : void 0,
+		groups: options.groups && options.groups.length > 0 ? options.groups : void 0
+	});
+	let publishError = false;
+	Object.entries(publishResults).forEach(([projectName, result]) => {
+		if (result.code === 0) require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.success(`Published ${projectName} successfully!`);
+		else {
+			publishError = true;
+			require__home_circleci_project_packages_nx_core_src_utils_common_logger.consola.fail(`Failed to publish ${projectName} with exit code ${result.code}`);
+		}
+	});
+	if (publishError) throw new Error("We got errors when publishing, check the logs");
+	return { success: true };
+};
+var executor_default = runExecutor;
+
+//#endregion
+module.exports = executor_default;

package/dist/executors/release/schema.d.ts

@@ -0,0 +1,12 @@
+//#region src/executors/release/schema.d.ts
+interface ReleaseExecutorSchema {} // eslint-disable-line
+interface ReleaseExecutorOptions {
+  skipPublish?: boolean;
+  preRelease?: boolean;
+  dryRun?: boolean;
+  verbose?: boolean;
+  groups?: string[];
+  specifier?: string;
+}
+//#endregion
+export { ReleaseExecutorOptions, ReleaseExecutorSchema };

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { CreateNodesContextV2, CreateNodesV2 } from "@nx/devkit";
+
+//#region src/index.d.ts
+interface MyPluginOptions {}
+declare const createNodesV2: CreateNodesV2<MyPluginOptions>;
+declare function createNodesInternal(configFilePath: string, options: MyPluginOptions, context: CreateNodesContextV2): Promise<{
+  projects: {
+    [x: string]: any;
+  };
+}>;
+//#endregion
+export { MyPluginOptions, createNodesInternal, createNodesV2 };