@aws/nx-plugin 1.0.0-rc.23 → 1.0.0-rc.25

package/src/utils/files/common/scripts/src/infra/stage-credentials/cdk-command.ts.template

@@ -4,6 +4,9 @@
  * Defaults to --require-approval=never (standard for local dev deploys).
  * If the user explicitly passes --require-approval with any value, we
  * respect their choice and don't add the default.
+ *
+ * Deploys default to --express (CloudFormation express mode) for faster
+ * local iteration. Pass --no-express to opt out.
  */
 export function buildCdkCommand(
   action: string,
@@ -12,7 +15,12 @@ export function buildCdkCommand(
   const hasRequireApproval = remainingArgs.some(
     (a) => a === '--require-approval' || a.startsWith('--require-approval='),
   );
-  return hasRequireApproval
-    ? ['cdk', action, ...remainingArgs]
-    : ['cdk', action, '--require-approval=never', ...remainingArgs];
+  const hasExpressFlag = remainingArgs.some(
+    (a) => a === '--express' || a === '--no-express',
+  );
+  const defaults = [
+    ...(hasRequireApproval ? [] : ['--require-approval=never']),
+    ...(action === 'deploy' && !hasExpressFlag ? ['--express'] : []),
+  ];
+  return ['cdk', action, ...defaults, ...remainingArgs];
 }

package/src/utils/files/common/scripts/src/rdb/mysql/wait-for-mysql-db.ts.template

@@ -0,0 +1,32 @@
+import { readFileSync } from 'fs';
+import { createConnection } from 'mariadb';
+
+const { port, dbName, dbUser, dbPassword, dbEngine } =
+  JSON.parse(readFileSync('config.json', 'utf-8')).localDev;
+
+const noop = () => undefined;
+const timeoutAt = Date.now() + 60000;
+
+while (Date.now() < timeoutAt) {
+  let conn: Awaited<ReturnType<typeof createConnection>> | undefined;
+  try {
+    conn = await createConnection({
+      host: 'localhost',
+      port: parseInt(port),
+      user: dbUser,
+      password: dbPassword,
+      database: dbName,
+      connectTimeout: 500,
+      allowPublicKeyRetrieval: true,
+    });
+    await conn.end();
+    console.log('Database is ready.');
+    process.exit(0);
+  } catch {
+    console.log('Database is not ready.');
+    await conn?.end().catch(noop);
+  }
+  await new Promise((r) => setTimeout(r, 200));
+}
+
+throw new Error(`Timed out waiting for ${dbEngine} on port ${port}`);

package/src/utils/files/common/scripts/src/rdb/postgres/wait-for-postgres-db.ts.template

@@ -0,0 +1,32 @@
+import { readFileSync } from 'fs';
+import { Client } from 'pg';
+
+const { port, dbName, dbUser, dbPassword, dbEngine } =
+  JSON.parse(readFileSync('config.json', 'utf-8')).localDev;
+
+const noop = () => undefined;
+const timeoutAt = Date.now() + 60000;
+
+while (Date.now() < timeoutAt) {
+  const client = new Client({
+    host: 'localhost',
+    port: parseInt(port),
+    user: dbUser,
+    password: dbPassword,
+    database: dbName,
+    connectionTimeoutMillis: 500,
+  });
+  client.on('error', noop);
+  try {
+    await client.connect();
+    await client.end();
+    console.log('Database is ready.');
+    process.exit(0);
+  } catch {
+    console.log('Database is not ready.');
+    await client.end().catch(noop);
+  }
+  await new Promise((r) => setTimeout(r, 200));
+}
+
+throw new Error(`Timed out waiting for ${dbEngine} on port ${port}`);

package/src/utils/files/common/scripts/src/rdb/{pull-image.ts.template → shared/pull-image.ts.template}

@@ -2,7 +2,7 @@ import { spawnSync } from 'child_process';
 import { readFileSync } from 'fs';
 
 const { containerEngine, image } =
-  JSON.parse(readFileSync('config.json', 'utf-8')).serveLocal;
+  JSON.parse(readFileSync('config.json', 'utf-8')).localDev;
 
 const inspect = spawnSync(containerEngine, ['image', 'inspect', image], {
   stdio: 'ignore',

package/src/utils/files/common/scripts/src/rdb/{start-container.ts.template → shared/start-container.ts.template}

@@ -10,7 +10,7 @@ const {
   dbUser,
   dbPassword,
   dbEngine,
-} = JSON.parse(readFileSync("config.json", "utf-8")).serveLocal;
+} = JSON.parse(readFileSync("config.json", "utf-8")).localDev;
 
 const containerExists = (): boolean =>
   spawnSync(containerEngine, ["container", "inspect", containerName], {
@@ -26,6 +26,21 @@ const isRunning = (): boolean => {
   return result.status === 0 && result.stdout.trim() === "true";
 };
 
+// Ensure the image is available locally before starting the container.
+const ensureImage = (): void => {
+  const inspect = spawnSync(containerEngine, ["image", "inspect", image], {
+    stdio: "ignore",
+  });
+  if (inspect.status !== 0) {
+    const pull = spawnSync(containerEngine, ["pull", image], {
+      stdio: "inherit",
+    });
+    if (pull.status !== 0) process.exit(pull.status ?? 1);
+  }
+};
+
+ensureImage();
+
 if (containerExists()) {
   if (!isRunning()) {
     const start = spawnSync(containerEngine, ["start", containerName], {

package/src/utils/files/terraform/src/core/asset-bucket/asset-bucket.tf.template

@@ -4,11 +4,11 @@ terraform {
   required_providers {
     aws = {
       source  = "hashicorp/aws"
-      version = "~> 6.0"
+      version = "<%- awsProviderVersion %>"
     }
     random = {
       source  = "hashicorp/random"
-      version = "~> 3.0"
+      version = "<%- randomProviderVersion %>"
     }
   }
 }

package/src/utils/files/terraform/src/core/runtime-config/appconfig/appconfig.tf.template

@@ -4,7 +4,7 @@ terraform {
   required_providers {
     aws = {
       source  = "hashicorp/aws"
-      version = ">= 5.0"
+      version = "<%- awsProviderVersion %>"
     }
   }
 }

package/src/utils/files/terraform/src/core/runtime-config/appconfig-deployment/appconfig-deployment.tf.template

@@ -4,15 +4,15 @@ terraform {
   required_providers {
     aws = {
       source  = "hashicorp/aws"
-      version = ">= 5.0"
+      version = "<%- awsProviderVersion %>"
     }
     local = {
       source  = "hashicorp/local"
-      version = "~> 2.0"
+      version = "<%- localProviderVersion %>"
     }
     null = {
       source  = "hashicorp/null"
-      version = ">= 3.0"
+      version = "<%- nullProviderVersion %>"
     }
   }
 }

package/src/utils/files/terraform/src/core/runtime-config/entry/entry.tf.template

@@ -2,7 +2,7 @@ terraform {
   required_providers {
     local = {
       source  = "hashicorp/local"
-      version = "~> 2.0"
+      version = "<%- localProviderVersion %>"
     }
   }
 }

package/src/utils/files/terraform/src/core/runtime-config/read/read.tf.template

@@ -2,11 +2,11 @@ terraform {
   required_providers {
     local = {
       source  = "hashicorp/local"
-      version = "~> 2.0"
+      version = "<%- localProviderVersion %>"
     }
     null = {
       source  = "hashicorp/null"
-      version = ">= 3.0"
+      version = "<%- nullProviderVersion %>"
     }
   }
 }

package/src/utils/files/website/hooks/sigv4/useSigV4.tsx.template

@@ -33,7 +33,7 @@ export const useSigV4 = (): SigV4Client => {
     {},
   );
 
-  const skipSigning = !cognitoProps && import.meta.env.MODE === 'serve-local';
+  const skipSigning = !cognitoProps && import.meta.env.MODE === 'local-dev';
 
   const withCachedCredentials = useCallback(
     async (

package/src/utils/format.js

@@ -1,54 +1,50 @@
-"use strict";
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_BIOME_CONFIG = void 0;
-exports.formatFilesInSubtree = formatFilesInSubtree;
-const tslib_1 = require("tslib");
-const nodejs_1 = require("@biomejs/js-api/nodejs");
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const path_1 = tslib_1.__importDefault(require("path"));
-exports.DEFAULT_BIOME_CONFIG = {
+ */ import { Biome } from "@biomejs/js-api/nodejs";
+import { execFileSync, execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+const require = createRequire(import.meta.url);
+export const DEFAULT_BIOME_CONFIG = {
     $schema: 'https://biomejs.dev/schemas/2.4.16/schema.json',
     root: true,
     formatter: {
         enabled: true,
         indentStyle: 'space',
         indentWidth: 2,
-        lineWidth: 80,
+        lineWidth: 80
     },
     javascript: {
         formatter: {
             quoteStyle: 'single',
-            trailingCommas: 'all',
-        },
+            trailingCommas: 'all'
+        }
     },
     css: {
         formatter: {
-            quoteStyle: 'single',
+            quoteStyle: 'single'
         },
         linter: {
-            enabled: false,
-        },
+            enabled: false
+        }
     },
     linter: {
         enabled: true,
         rules: {
             recommended: false,
             correctness: {
-                noUndeclaredDependencies: 'warn',
-            },
-        },
+                noUndeclaredDependencies: 'warn'
+            }
+        }
     },
     assist: {
         actions: {
             source: {
-                organizeImports: 'on',
-            },
-        },
+                organizeImports: 'on'
+            }
+        }
     },
     files: {
         includes: [
@@ -58,9 +54,9 @@ exports.DEFAULT_BIOME_CONFIG = {
             '!**/node_modules',
             '!**/.nx',
             '!**/.venv',
-            '!**/*.css',
-        ],
-    },
+            '!**/*.css'
+        ]
+    }
 };
 const BIOME_FORMATTABLE_EXTENSIONS = new Set([
     '.ts',
@@ -73,98 +69,95 @@ const BIOME_FORMATTABLE_EXTENSIONS = new Set([
     '.cts',
     '.json',
     '.jsonc',
-    '.css',
+    '.css'
 ]);
 /**
  * Format files in the given directory within the tree.
  * Handles both TypeScript/JavaScript/JSON (via biome) and Python (via ruff) files.
  * See https://github.com/nrwl/nx/blob/4cd640a9187954505d12de5b6d76a90d8ce4c2eb/packages/devkit/src/generators/format-files.ts#L11
- */
-async function formatFilesInSubtree(tree, dir) {
-    const changedFiles = tree
-        .listChanges()
-        .filter((file) => file.type !== 'DELETE')
-        .filter((file) => (dir ? file.path.startsWith(dir) : true));
-    const pyFiles = changedFiles.filter((file) => file.path.endsWith('.py'));
-    const otherFiles = changedFiles.filter((file) => BIOME_FORMATTABLE_EXTENSIONS.has(path_1.default.extname(file.path)));
+ */ export async function formatFilesInSubtree(tree, dir) {
+    const changedFiles = tree.listChanges().filter((file)=>file.type !== 'DELETE').filter((file)=>dir ? file.path.startsWith(dir) : true);
+    const pyFiles = changedFiles.filter((file)=>file.path.endsWith('.py'));
+    const otherFiles = changedFiles.filter((file)=>BIOME_FORMATTABLE_EXTENSIONS.has(path.extname(file.path)));
     // Format Python files with ruff (lint fixes + formatting)
-    for (const file of pyFiles) {
+    for (const file of pyFiles){
         try {
-            const content = ruffFixAndFormat(file.content.toString('utf-8'), file.path);
+            const content = ruffFixAndFormat(file.content.toString('utf-8'), file.path, hasRuffConfigOnDisk(tree, file.path));
             tree.write(file.path, content);
-        }
-        catch {
-            // Silently skip ruff formatting failures
+        } catch  {
+        // Silently skip ruff formatting failures
         }
     }
-    if (otherFiles.length === 0)
-        return;
+    if (otherFiles.length === 0) return;
     // Use the workspace's own Biome CLI (its version and config) when biome.json
     // exists on disk; otherwise format via the bundled library API with the
     // in-memory tree config. The CLI path does not see in-tree config changes.
-    if ((0, fs_1.existsSync)(path_1.default.join(tree.root, 'biome.json'))) {
+    if (existsSync(path.join(tree.root, 'biome.json'))) {
         formatWithBiomeCli(tree, otherFiles);
-    }
-    else {
+    } else {
         formatWithBiomeApi(tree, otherFiles);
     }
 }
 /**
  * Format files via the workspace's Biome CLI, run from the workspace root so it
  * discovers the on-disk biome.json.
- */
-function formatWithBiomeCli(tree, files) {
+ */ function formatWithBiomeCli(tree, files) {
     const biome = getBiomeCommand(tree.root);
     if (!biome) {
         // Fall back to the library API if the CLI cannot be resolved
         formatWithBiomeApi(tree, files);
         return;
     }
-    for (const file of files) {
+    for (const file of files){
         try {
-            const content = (0, child_process_1.execFileSync)(biome.command, [...biome.args, 'format', `--stdin-file-path=${file.path}`], {
+            const content = execFileSync(biome.command, [
+                ...biome.args,
+                'format',
+                `--stdin-file-path=${file.path}`
+            ], {
                 input: file.content?.toString('utf-8') ?? '',
                 encoding: 'utf-8',
                 cwd: tree.root,
-                stdio: ['pipe', 'pipe', 'pipe'],
+                stdio: [
+                    'pipe',
+                    'pipe',
+                    'pipe'
+                ]
             });
             tree.write(file.path, content);
-        }
-        catch {
-            // Leave individual files that fail to format untouched
+        } catch  {
+        // Leave individual files that fail to format untouched
         }
     }
 }
 /**
  * Format files via the bundled Biome library API, applying the in-memory tree
  * config.
- */
-function formatWithBiomeApi(tree, files) {
+ */ function formatWithBiomeApi(tree, files) {
     try {
-        const biome = new nodejs_1.Biome();
+        const biome = new Biome();
         const { projectKey } = biome.openProject();
         // Apply the workspace biome.json if it exists in the tree, otherwise the defaults.
         const treeConfig = tree.read('biome.json', 'utf-8');
-        biome.applyConfiguration(projectKey, treeConfig ? JSON.parse(treeConfig) : exports.DEFAULT_BIOME_CONFIG);
-        for (const file of files) {
+        biome.applyConfiguration(projectKey, treeConfig ? JSON.parse(treeConfig) : DEFAULT_BIOME_CONFIG);
+        for (const file of files){
             try {
-                const { content } = biome.formatContent(projectKey, file.content?.toString('utf-8') ?? '', { filePath: file.path });
+                const { content } = biome.formatContent(projectKey, file.content?.toString('utf-8') ?? '', {
+                    filePath: file.path
+                });
                 tree.write(file.path, content);
-            }
-            catch {
-                // Leave individual files that fail to format untouched
+            } catch  {
+            // Leave individual files that fail to format untouched
             }
         }
-    }
-    catch {
-        // Silently skip formatting failures
+    } catch  {
+    // Silently skip formatting failures
     }
 }
 /**
  * Resolve the `@biomejs/biome` CLI from the user's workspace, falling back to a
  * `biome` binary on the PATH.
- */
-const _biomeCommands = new Map();
+ */ const _biomeCommands = new Map();
 function getBiomeCommand(root) {
     if (_biomeCommands.has(root)) {
         return _biomeCommands.get(root) ?? undefined;
@@ -172,30 +165,43 @@ function getBiomeCommand(root) {
     // Run via node for cross-platform execution of the bin shim.
     try {
         const pkgJsonPath = require.resolve('@biomejs/biome/package.json', {
-            paths: [root, __dirname],
+            paths: [
+                root,
+                import.meta.dirname
+            ]
         });
-        const pkgJson = require(pkgJsonPath);
+        const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
         const binRelative = typeof pkgJson.bin === 'string' ? pkgJson.bin : pkgJson.bin?.biome;
         if (binRelative) {
-            const binPath = path_1.default.join(path_1.default.dirname(pkgJsonPath), binRelative);
-            const command = { command: process.execPath, args: [binPath] };
+            const binPath = path.join(path.dirname(pkgJsonPath), binRelative);
+            const command = {
+                command: process.execPath,
+                args: [
+                    binPath
+                ]
+            };
             _biomeCommands.set(root, command);
             return command;
         }
-    }
-    catch {
-        // Fall back to a biome binary on the PATH
+    } catch  {
+    // Fall back to a biome binary on the PATH
     }
     try {
-        (0, child_process_1.execSync)('biome --version', {
+        execSync('biome --version', {
             encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
+            stdio: [
+                'pipe',
+                'pipe',
+                'pipe'
+            ]
         });
-        const command = { command: 'biome', args: [] };
+        const command = {
+            command: 'biome',
+            args: []
+        };
         _biomeCommands.set(root, command);
         return command;
-    }
-    catch {
+    } catch  {
         _biomeCommands.set(root, null);
         return undefined;
     }
@@ -203,42 +209,86 @@ function getBiomeCommand(root) {
 /**
  * Find the ruff command. Tries 'uv run ruff', then 'uvx ruff'.
  * Matches how @nxlv/python runs ruff via the UV provider.
- */
-let _ruffCommand;
+ */ let _ruffCommand;
 function getRuffCommand() {
     if (_ruffCommand !== undefined) {
         return _ruffCommand || undefined;
     }
-    for (const cmd of ['uv run ruff', 'uvx ruff']) {
+    for (const cmd of [
+        'uv run ruff',
+        'uvx ruff'
+    ]){
         try {
-            (0, child_process_1.execSync)(`${cmd} --version`, {
+            execSync(`${cmd} --version`, {
                 encoding: 'utf-8',
-                stdio: ['pipe', 'pipe', 'pipe'],
+                stdio: [
+                    'pipe',
+                    'pipe',
+                    'pipe'
+                ]
             });
             _ruffCommand = cmd;
             return cmd;
-        }
-        catch {
-            // Try next command
+        } catch  {
+        // Try next command
         }
     }
     _ruffCommand = '';
     return undefined;
 }
+/**
+ * Whether ruff would discover a config on disk for a file, by walking from its
+ * directory up to the workspace root looking for `.ruff.toml`, `ruff.toml`, or a
+ * `pyproject.toml` with a `[tool.ruff]` section — the same files ruff itself
+ * resolves. The walk stops at `tree.root` so a stray config in a parent of the
+ * workspace (or the home directory) is never treated as the project's. Used to
+ * decide whether to nudge ruff towards import sorting (see
+ * {@link ruffFixAndFormat}).
+ */ function hasRuffConfigOnDisk(tree, filePath) {
+    const root = path.resolve(tree.root);
+    let dir = path.resolve(root, path.dirname(filePath));
+    while(true){
+        if (existsSync(path.join(dir, '.ruff.toml')) || existsSync(path.join(dir, 'ruff.toml'))) {
+            return true;
+        }
+        const pyproject = path.join(dir, 'pyproject.toml');
+        if (existsSync(pyproject) && readFileSync(pyproject, 'utf-8').includes('[tool.ruff')) {
+            return true;
+        }
+        const parent = path.dirname(dir);
+        // Stop once the workspace root has been checked (or we hit the FS root).
+        if (dir === root || parent === dir) {
+            return false;
+        }
+        dir = parent;
+    }
+}
 /**
  * Run ruff check --fix and ruff format on Python file content via stdin.
  * Applies all configured lint fixes (including import sorting) and formatting.
- */
-function ruffFixAndFormat(content, filePath) {
+ *
+ * When no ruff config exists on disk (`hasConfig` false) ruff falls back to its
+ * defaults, which omit isort — but generated projects enable rule `I` and their
+ * build fails on unsorted imports (I001). In that case we add `--extend-select
+ * I` so import sorting matches what the build enforces. When a config does
+ * exist we defer to it entirely, honouring the user's rule selection.
+ */ function ruffFixAndFormat(content, filePath, hasConfig) {
     const ruff = getRuffCommand();
-    if (!ruff)
-        return content;
+    if (!ruff) return content;
+    const extendSelect = hasConfig ? '' : ' --extend-select I';
     // First apply lint fixes (import sorting, unused imports, etc.)
     try {
-        const result = (0, child_process_1.execSync)(`${ruff} check --fix --stdin-filename ${filePath} -`, { input: content, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        const result = execSync(`${ruff} check --fix${extendSelect} --stdin-filename ${filePath} -`, {
+            input: content,
+            encoding: 'utf-8',
+            stdio: [
+                'pipe',
+                'pipe',
+                'pipe'
+            ]
+        });
         content = result;
-    }
-    catch (e) {
+    } catch (e) {
         // ruff check exits non-zero when it finds unfixable issues,
         // but stdout still contains the fixed content
         if (e.stdout) {
@@ -247,15 +297,19 @@ function ruffFixAndFormat(content, filePath) {
     }
     // Then apply formatting
     try {
-        content = (0, child_process_1.execSync)(`${ruff} format --stdin-filename ${filePath} -`, {
+        content = execSync(`${ruff} format --stdin-filename ${filePath} -`, {
             input: content,
             encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
+            stdio: [
+                'pipe',
+                'pipe',
+                'pipe'
+            ]
         });
-    }
-    catch {
-        // Fall through with whatever content we have
+    } catch  {
+    // Fall through with whatever content we have
     }
     return content;
 }
+
 //# sourceMappingURL=format.js.map