@nx/docker 0.0.0-pr-31634-cb74636

package/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2017-2025 Narwhal Technologies Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,68 @@
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Repos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
+
+<div style="text-align: center;">
+
+[![CircleCI](https://circleci.com/gh/nrwl/nx.svg?style=svg)](https://circleci.com/gh/nrwl/nx)
+[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
+[![NPM Version](https://badge.fury.io/js/nx.svg)](https://www.npmjs.com/package/nx)
+[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+[![Join the chat at https://gitter.im/nrwl-nx/community](https://badges.gitter.im/nrwl-nx/community.svg)](https://gitter.im/nrwl-nx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
+
+</div>
+
+
+<hr>
+
+# Nx: Smart Repos · Fast Builds
+
+An AI-first build platform that connects everything from your editor to CI. Helping you deliver fast, without breaking things.
+
+This package is a [Docker plugin for Nx](https://nx.dev/nx-api/docker).
+
+## Getting Started
+
+### Creating an Nx Workspace
+
+**Using `npx`**
+
+```bash
+npx create-nx-workspace
+```
+
+**Using `npm init`**
+
+```bash
+npm init nx-workspace
+```
+
+**Using `yarn create`**
+
+```bash
+yarn create nx-workspace
+```
+
+### Adding Nx to an Existing Repository
+
+Run:
+
+```bash
+npx nx@latest init
+```
+
+## Documentation & Resources
+
+- [Nx.Dev: Documentation, Guides, Tutorials](https://nx.dev)
+- [Intro to Nx](https://nx.dev/getting-started/intro)
+- [Official Nx YouTube Channel](https://www.youtube.com/@NxDevtools)
+- [Blog Posts About Nx](https://nx.dev/blog)
+
+<p style="text-align: center;"><a href="https://nx.dev/#learning-materials" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-courses-and-videos.svg" 
+width="100%" alt="Nx - Smart Repos · Fast Builds"></a></p>
+

package/executors.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "executors": {
+    "release-publish": {
+      "implementation": "./src/executors/release-publish/release-publish.impl",
+      "schema": "./src/executors/release-publish/schema.json",
+      "description": "DO NOT INVOKE DIRECTLY WITH `nx run`. Use `nx release publish` instead.",
+      "hidden": true
+    }
+  }
+}

package/index.d.ts

@@ -0,0 +1 @@
+export { createNodesV2, DockerPluginOptions } from './src/plugins/plugin';

package/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodesV2 = void 0;
+var plugin_1 = require("./src/plugins/plugin");
+Object.defineProperty(exports, "createNodesV2", { enumerable: true, get: function () { return plugin_1.createNodesV2; } });

package/migrations.json

@@ -0,0 +1 @@
+{}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@nx/docker",
+  "description": "The Nx Plugin for Docker to aid in containerizing projects.",
+  "version": "0.0.0-pr-31634-cb74636",
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nrwl/nx.git",
+    "directory": "packages/docker"
+  },
+  "bugs": {
+    "url": "https://github.com/nrwl/nx/issues"
+  },
+  "keywords": [
+    "Monorepo",
+    "Docker",
+    "Containers"
+  ],
+  "author": "Colum Ferry",
+  "license": "MIT",
+  "homepage": "https://nx.dev",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./release/version-utils": {
+      "types": "./src/release/version-utils.d.ts",
+      "default": "./src/release/version-utils.js"
+    },
+    "./package.json": {
+      "default": "./package.json"
+    }
+  },
+  "executors": "./executors.json",
+  "dependencies": {
+    "@nx/devkit": "0.0.0-pr-31634-cb74636",
+    "tslib": "^2.3.0"
+  },
+  "types": "./index.d.ts"
+}

package/src/executors/release-publish/release-publish.impl.d.ts

@@ -0,0 +1,5 @@
+import { ExecutorContext } from '@nx/devkit';
+import { DockerReleasePublishSchema } from './schema';
+export default function dockerReleasePublish(schema: DockerReleasePublishSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/src/executors/release-publish/release-publish.impl.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = dockerReleasePublish;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const fs_1 = require("fs");
+async function dockerReleasePublish(schema, context) {
+    const projectConfig = context.projectGraph.nodes[context.projectName];
+    const options = normalizeOptions(projectConfig, schema);
+    if (!options.dryRun) {
+        const digest = dockerPush(options.imageReference);
+        devkit_1.logger.log(`Successfully pushed ${options.imageReference}. Digest: ${digest}`);
+    }
+    else {
+        devkit_1.logger.log(`Docker Image ${options.imageReference} was not pushed as --dry-run is enabled.`);
+    }
+    return {
+        success: true,
+    };
+}
+function normalizeOptions(projectConfig, schema) {
+    return {
+        imageReference: findImageReference(projectConfig, schema),
+        dryRun: process.env.NX_DRY_RUN === 'true' || schema.dryRun || false,
+    };
+}
+function findImageReference(projectConfig, schema) {
+    let imageRef = readVersionFromFile(projectConfig.data.root);
+    if (imageRef) {
+        if (checkDockerImageExistsLocally(imageRef)) {
+            return imageRef;
+        }
+        throw new Error(`Could not find Docker Image ${imageRef}. Did you run 'nx release version'?`);
+    }
+}
+function readVersionFromFile(projectRoot) {
+    const versionFilePath = (0, path_1.join)(projectRoot, '.docker-version');
+    if (!(0, fs_1.existsSync)(versionFilePath)) {
+        throw new Error("Could not find .docker-version file. Did you run 'nx release version'?");
+    }
+    const version = (0, fs_1.readFileSync)(versionFilePath, { encoding: 'utf8' });
+    return version.trim();
+}
+function checkDockerImageExistsLocally(imageRef) {
+    try {
+        const result = (0, child_process_1.execSync)(`docker images --filter "reference=${imageRef}" --quiet`, { encoding: 'utf8' });
+        return result.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function dockerPush(imageReference) {
+    try {
+        const result = (0, child_process_1.execSync)(`docker push ${imageReference} --quiet`, {
+            encoding: 'utf8',
+        });
+        return result.trim();
+    }
+    catch (e) {
+        devkit_1.logger.error(`Failed to push ${imageReference}`);
+        throw e;
+    }
+}

package/src/executors/release-publish/schema.d.ts

@@ -0,0 +1,8 @@
+export interface DockerReleasePublishSchema {
+  dryRun?: boolean;
+}
+
+export interface NormalizedDockerReleasePublishSchema {
+  imageReference: string;
+  dryRun: boolean;
+}

package/src/executors/release-publish/schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Implementation details of `nx release publish`",
+  "description": "DO NOT INVOKE DIRECTLY WITH `nx run`. Use `nx release publish` instead.",
+  "type": "object",
+  "properties": {
+    "dryRun": {
+      "type": "boolean",
+      "description": "Whether to run the command without actually publishing the image to the registry."
+    }
+  },
+  "required": []
+}

package/src/plugins/plugin.d.ts

@@ -0,0 +1,6 @@
+import { type CreateNodesV2 } from '@nx/devkit';
+export interface DockerPluginOptions {
+    buildTarget?: string;
+    runTarget?: string;
+}
+export declare const createNodesV2: CreateNodesV2<DockerPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodesV2 = void 0;
+const devkit_1 = require("@nx/devkit");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const file_hasher_1 = require("nx/src/hasher/file-hasher");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+function readTargetsCache(cachePath) {
+    return (0, fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
+}
+function writeTargetsCache(cachePath, results) {
+    (0, devkit_1.writeJsonFile)(cachePath, results ?? {});
+}
+const dockerfileGlob = '**/Dockerfile';
+exports.createNodesV2 = [
+    dockerfileGlob,
+    async (configFilePaths, options, context) => {
+        const optionsHash = (0, file_hasher_1.hashObject)(options);
+        const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, `docker-${optionsHash}.hash`);
+        const targetsCache = readTargetsCache(cachePath);
+        try {
+            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, targetsCache), configFilePaths, options, context);
+        }
+        finally {
+            writeTargetsCache(cachePath, targetsCache);
+        }
+    },
+];
+async function createNodesInternal(configFilePath, options, context, targetsCache) {
+    const projectRoot = (0, path_1.dirname)(configFilePath);
+    const normalizedOptions = normalizePluginOptions(options);
+    const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, normalizedOptions, context);
+    targetsCache[hash] ??= await createDockerTargets(projectRoot, normalizedOptions, context);
+    const { targets, metadata } = targetsCache[hash];
+    return {
+        projects: {
+            [projectRoot]: {
+                root: projectRoot,
+                targets,
+                metadata,
+            },
+        },
+    };
+}
+async function createDockerTargets(projectRoot, options, context) {
+    const imageRef = projectRoot.replace(/^[\\/]/, '').replace(/[\\/\s]+/g, '-');
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const targets = {};
+    targets[options.buildTarget] = {
+        command: `docker build .`,
+        options: {
+            cwd: projectRoot,
+            args: [`--tag ${imageRef}`],
+        },
+        inputs: [
+            ...('production' in namedInputs
+                ? ['production', '^production']
+                : ['default', '^default']),
+        ],
+        metadata: {
+            technologies: ['docker'],
+            description: `Run Docker build`,
+            help: {
+                command: `docker build --help`,
+                example: {},
+            },
+        },
+    };
+    targets[options.runTarget] = {
+        dependsOn: [options.buildTarget],
+        command: `docker run {args} ${imageRef}`,
+        options: {
+            cwd: projectRoot,
+        },
+        inputs: [
+            ...('production' in namedInputs
+                ? ['production', '^production']
+                : ['default', '^default']),
+        ],
+        metadata: {
+            technologies: ['docker'],
+            description: `Run Docker run`,
+            help: {
+                command: `docker run --help`,
+                example: {},
+            },
+        },
+    };
+    targets['nx-release-publish'] = {
+        executor: '@nx/docker:release-publish',
+    };
+    return { targets, metadata: {} };
+}
+function normalizePluginOptions(options) {
+    return {
+        buildTarget: options.buildTarget ?? 'docker:build',
+        runTarget: options.runTarget ?? 'docker:run',
+    };
+}

package/src/release/version-pattern-utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Support Tokens in Version Patterns
+ * {projectName} - the name of the project
+ * {currentDate} - the current date in YY.MM.DD format
+ * {currentDate|DATE FORMAT} - the current date with custom format such as YYMM.DD
+ * {commitSha} - The full commit sha for the current commit
+ * {shortCommitSha} - The seven character commit sha for the current commit
+ */
+export interface PatternTokens {
+    projectName: string;
+    currentDate: Date;
+    commitSha: string;
+    shortCommitSha: string;
+}
+export declare function interpolateVersionPattern(versionPattern: string, data: Partial<PatternTokens>): string;

package/src/release/version-pattern-utils.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolateVersionPattern = interpolateVersionPattern;
+const git_utils_1 = require("nx/src/utils/git-utils");
+const tokenRegex = /\{([^|{}]+)(?:\|([^{}]+))?\}/g;
+function formatDate(date, format) {
+    const year = String(date.getFullYear());
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    return format
+        .replace(/YYYY/g, year)
+        .replace(/YY/g, year.slice(-2))
+        .replace(/MM/g, month)
+        .replace(/DD/g, day)
+        .replace(/HH/g, hours)
+        .replace(/mm/g, minutes)
+        .replace(/ss/g, seconds);
+}
+function interpolateVersionPattern(versionPattern, data) {
+    const commitSha = (0, git_utils_1.getLatestCommitSha)();
+    const substitutions = {
+        projectName: data.projectName ?? '',
+        currentDate: data.currentDate ?? new Date(),
+        commitSha: data.commitSha ?? commitSha,
+        shortCommitSha: data.shortCommitSha ?? commitSha.slice(0, 7),
+    };
+    return versionPattern.replace(tokenRegex, (match, identifier, format) => {
+        const value = substitutions[identifier];
+        if (value === undefined) {
+            return match; // Keep original token if no data
+        }
+        // Handle date formatting
+        if (identifier === 'currentDate') {
+            if (format) {
+                return formatDate(value, format);
+            }
+            else {
+                return value.toISOString();
+            }
+        }
+        return value;
+    });
+}

package/src/release/version-utils.d.ts

@@ -0,0 +1,6 @@
+import { ProjectGraphProjectNode } from '@nx/devkit';
+import type { FinalConfigForProject } from 'nx/src/command-line/release/version/release-group-processor';
+export declare function handleDockerVersion(projectGraphNode: ProjectGraphProjectNode, finalConfigForProject: FinalConfigForProject): Promise<{
+    newVersion: string;
+    logs: string[];
+}>;

package/src/release/version-utils.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDockerVersion = handleDockerVersion;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const enquirer_1 = require("enquirer");
+const version_pattern_utils_1 = require("./version-pattern-utils");
+const DEFAULT_VERSION_SCHEMES = {
+    production: '{currentDate|YYMM.DD}.{shortCommitSha}',
+    hotfix: '{currentDate|YYMM.DD}.{shortCommitSha}-hotfix',
+};
+async function handleDockerVersion(projectGraphNode, finalConfigForProject) {
+    const availableVersionSchemes = finalConfigForProject.dockerOptions.versionSchemes ??
+        DEFAULT_VERSION_SCHEMES;
+    const versionScheme = await promptForNewVersion(availableVersionSchemes, projectGraphNode.name);
+    const newVersion = calculateNewVersion(projectGraphNode.name, versionScheme, availableVersionSchemes);
+    const logs = updateProjectVersion(newVersion, projectGraphNode.data.root, finalConfigForProject.dockerOptions.repositoryName, finalConfigForProject.dockerOptions.registryUrl);
+    return {
+        newVersion,
+        logs,
+    };
+}
+async function promptForNewVersion(versionSchemes, projectName) {
+    const { versionScheme } = await (0, enquirer_1.prompt)({
+        name: 'versionScheme',
+        type: 'select',
+        message: `What type of release would you like to make for project "${projectName}"?`,
+        choices: Object.keys(versionSchemes).map((vs) => ({
+            name: vs,
+            message: vs,
+            value: vs,
+            hint: (0, version_pattern_utils_1.interpolateVersionPattern)(versionSchemes[vs], { projectName }),
+        })),
+    });
+    return versionScheme;
+}
+function calculateNewVersion(projectName, versionScheme, versionSchemes) {
+    if (!(versionScheme in versionSchemes)) {
+        throw new Error(`Could not find version scheme '${versionScheme}'. Available options are: ${Object.keys(versionSchemes).join(', ')}.`);
+    }
+    return (0, version_pattern_utils_1.interpolateVersionPattern)(versionSchemes[versionScheme], {
+        projectName,
+    });
+}
+function updateProjectVersion(newVersion, projectRoot, repositoryName, registry) {
+    const isDryRun = process.env.NX_DRY_RUN && process.env.NX_DRY_RUN !== 'false';
+    const imageRef = getDefaultImageReference(projectRoot);
+    const newImageRef = getImageReference(projectRoot, repositoryName, registry);
+    const fullImageRef = `${newImageRef}:${newVersion}`;
+    if (!isDryRun) {
+        (0, child_process_1.execSync)(`docker tag ${imageRef} ${fullImageRef}`);
+    }
+    const logs = [`Image ${imageRef} tagged with ${fullImageRef}.`];
+    if (isDryRun) {
+        logs.push(`No changes were applied as --dry-run is enabled.`);
+    }
+    else {
+        (0, fs_1.writeFileSync)((0, path_1.join)(projectRoot, '.docker-version'), fullImageRef);
+    }
+    return logs;
+}
+function getImageReference(projectRoot, repositoryName, registry) {
+    let imageRef = repositoryName ?? getDefaultImageReference(projectRoot);
+    if (registry) {
+        imageRef = `${registry}/${imageRef}`;
+    }
+    return imageRef;
+}
+function getDefaultImageReference(projectRoot) {
+    return projectRoot.replace(/^[\\/]/, '').replace(/[\\/\s]+/g, '-');
+}