@depup/aws-cdk 2.1117.0-depup.0

package/lib/commands/flags/router.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlagOperationRouter = void 0;
+class FlagOperationRouter {
+    constructor(validator, interactiveHandler, flagOperations) {
+        this.validator = validator;
+        this.interactiveHandler = interactiveHandler;
+        this.flagOperations = flagOperations;
+    }
+    /** Routes flag operations to appropriate handlers based on parameters */
+    async route(params) {
+        if (params.interactive) {
+            await this.handleInteractiveMode();
+            return;
+        }
+        if (params.safe) {
+            await this.flagOperations.setSafeFlags(params);
+            return;
+        }
+        const isValid = await this.validator.validateParams(params);
+        if (!isValid)
+            return;
+        if (params.set) {
+            await this.handleSetOperations(params);
+        }
+        else {
+            await this.flagOperations.displayFlags(params);
+            await this.showHelpMessage(params);
+        }
+    }
+    /** Handles flag setting operations, routing to single or multiple flag methods */
+    async handleSetOperations(params) {
+        if (params.FLAGNAME && params.value) {
+            await this.flagOperations.setFlag(params);
+        }
+        else if (params.all || params.unconfigured) {
+            await this.flagOperations.setMultipleFlags(params);
+        }
+    }
+    /** Manages interactive mode */
+    async handleInteractiveMode() {
+        while (true) {
+            const interactiveParams = await this.interactiveHandler.handleInteractiveMode();
+            if (!interactiveParams)
+                return;
+            await this.flagOperations.execute(interactiveParams);
+            if (!interactiveParams.FLAGNAME) {
+                return;
+            }
+        }
+    }
+    /** Shows help message when no specific options are provided */
+    async showHelpMessage(params) {
+        if (!params.all && !params.FLAGNAME) {
+            await this.flagOperations.displayHelpMessage();
+        }
+    }
+}
+exports.FlagOperationRouter = FlagOperationRouter;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/commands/flags/types.d.ts

@@ -0,0 +1,12 @@
+import type { FlagsOptions } from '../../cli/user-input';
+export declare enum FlagsMenuOptions {
+    ALL_TO_RECOMMENDED = "Set all flags to recommended values",
+    UNCONFIGURED_TO_RECOMMENDED = "Set unconfigured flags to recommended values",
+    UNCONFIGURED_TO_DEFAULT = "Set unconfigured flags to their implied configuration (record current behavior)",
+    MODIFY_SPECIFIC_FLAG = "Modify a specific flag",
+    EXIT = "Exit"
+}
+export interface FlagOperationsParams extends FlagsOptions {
+    /** User provided --app option */
+    app?: string;
+}

package/lib/commands/flags/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlagsMenuOptions = void 0;
+var FlagsMenuOptions;
+(function (FlagsMenuOptions) {
+    FlagsMenuOptions["ALL_TO_RECOMMENDED"] = "Set all flags to recommended values";
+    FlagsMenuOptions["UNCONFIGURED_TO_RECOMMENDED"] = "Set unconfigured flags to recommended values";
+    FlagsMenuOptions["UNCONFIGURED_TO_DEFAULT"] = "Set unconfigured flags to their implied configuration (record current behavior)";
+    FlagsMenuOptions["MODIFY_SPECIFIC_FLAG"] = "Modify a specific flag";
+    FlagsMenuOptions["EXIT"] = "Exit";
+})(FlagsMenuOptions || (exports.FlagsMenuOptions = FlagsMenuOptions = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQSxJQUFZLGdCQU1YO0FBTkQsV0FBWSxnQkFBZ0I7SUFDMUIsOEVBQTBELENBQUE7SUFDMUQsZ0dBQTRFLENBQUE7SUFDNUUsK0hBQTJHLENBQUE7SUFDM0csbUVBQStDLENBQUE7SUFDL0MsaUNBQWEsQ0FBQTtBQUNmLENBQUMsRUFOVyxnQkFBZ0IsZ0NBQWhCLGdCQUFnQixRQU0zQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRmxhZ3NPcHRpb25zIH0gZnJvbSAnLi4vLi4vY2xpL3VzZXItaW5wdXQnO1xuXG5leHBvcnQgZW51bSBGbGFnc01lbnVPcHRpb25zIHtcbiAgQUxMX1RPX1JFQ09NTUVOREVEID0gJ1NldCBhbGwgZmxhZ3MgdG8gcmVjb21tZW5kZWQgdmFsdWVzJyxcbiAgVU5DT05GSUdVUkVEX1RPX1JFQ09NTUVOREVEID0gJ1NldCB1bmNvbmZpZ3VyZWQgZmxhZ3MgdG8gcmVjb21tZW5kZWQgdmFsdWVzJyxcbiAgVU5DT05GSUdVUkVEX1RPX0RFRkFVTFQgPSAnU2V0IHVuY29uZmlndXJlZCBmbGFncyB0byB0aGVpciBpbXBsaWVkIGNvbmZpZ3VyYXRpb24gKHJlY29yZCBjdXJyZW50IGJlaGF2aW9yKScsXG4gIE1PRElGWV9TUEVDSUZJQ19GTEFHID0gJ01vZGlmeSBhIHNwZWNpZmljIGZsYWcnLFxuICBFWElUID0gJ0V4aXQnLFxufVxuXG5leHBvcnQgaW50ZXJmYWNlIEZsYWdPcGVyYXRpb25zUGFyYW1zIGV4dGVuZHMgRmxhZ3NPcHRpb25zIHtcbiAgLyoqIFVzZXIgcHJvdmlkZWQgLS1hcHAgb3B0aW9uICovXG4gIGFwcD86IHN0cmluZztcbn1cbiJdfQ==

package/lib/commands/flags/validator.d.ts

@@ -0,0 +1,22 @@
+import type { FlagOperationsParams } from './types';
+import type { IoHelper } from '../../api-private';
+export declare class FlagValidator {
+    private readonly ioHelper;
+    constructor(ioHelper: IoHelper);
+    /** Shows error message when CDK version is incompatible with flags command */
+    showIncompatibleVersionError(): Promise<void>;
+    /** Validates all parameters and returns true if valid, false if any validation fails */
+    validateParams(params: FlagOperationsParams): Promise<boolean>;
+    /** Validates that --all and specific flag names are not used together */
+    private validateFlagNameAndAll;
+    /** Validates that modification options require --set flag */
+    private validateSetRequirement;
+    /** Validates that --value requires a specific flag name */
+    private validateValueRequirement;
+    /** Validates that mutually exclusive options are not used together */
+    private validateMutuallyExclusive;
+    /** Validates that --unconfigured is not used with specific flag names */
+    private validateUnconfiguredUsage;
+    /** Validates that --set operations have required accompanying options */
+    private validateSetWithFlags;
+}

package/lib/commands/flags/validator.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlagValidator = void 0;
+class FlagValidator {
+    constructor(ioHelper) {
+        this.ioHelper = ioHelper;
+    }
+    /** Shows error message when CDK version is incompatible with flags command */
+    async showIncompatibleVersionError() {
+        await this.ioHelper.defaults.error('The \'cdk flags\' command is not compatible with the AWS CDK library used by your application. Please upgrade to 2.212.0 or above.');
+    }
+    /** Validates all parameters and returns true if valid, false if any validation fails */
+    async validateParams(params) {
+        const validations = [
+            () => this.validateFlagNameAndAll(params),
+            () => this.validateSetRequirement(params),
+            () => this.validateValueRequirement(params),
+            () => this.validateMutuallyExclusive(params),
+            () => this.validateUnconfiguredUsage(params),
+            () => this.validateSetWithFlags(params),
+        ];
+        for (const validation of validations) {
+            const isValid = await validation();
+            if (!isValid)
+                return false;
+        }
+        return true;
+    }
+    /** Validates that --all and specific flag names are not used together */
+    async validateFlagNameAndAll(params) {
+        if (params.FLAGNAME && params.all) {
+            await this.ioHelper.defaults.error('Error: Cannot use both --all and a specific flag name. Please use either --all to show all flags or specify a single flag name.');
+            return false;
+        }
+        return true;
+    }
+    /** Validates that modification options require --set flag */
+    async validateSetRequirement(params) {
+        if ((params.value || params.recommended || params.default || params.unconfigured) && !params.set) {
+            await this.ioHelper.defaults.error('Error: This option can only be used with --set.');
+            return false;
+        }
+        return true;
+    }
+    /** Validates that --value requires a specific flag name */
+    async validateValueRequirement(params) {
+        if (params.value && !params.FLAGNAME) {
+            await this.ioHelper.defaults.error('Error: --value requires a specific flag name. Please specify a flag name when providing a value.');
+            return false;
+        }
+        return true;
+    }
+    /** Validates that mutually exclusive options are not used together */
+    async validateMutuallyExclusive(params) {
+        if (params.recommended && params.default) {
+            await this.ioHelper.defaults.error('Error: Cannot use both --recommended and --default. Please choose one option.');
+            return false;
+        }
+        if (params.unconfigured && params.all) {
+            await this.ioHelper.defaults.error('Error: Cannot use both --unconfigured and --all. Please choose one option.');
+            return false;
+        }
+        return true;
+    }
+    /** Validates that --unconfigured is not used with specific flag names */
+    async validateUnconfiguredUsage(params) {
+        if (params.unconfigured && params.FLAGNAME) {
+            await this.ioHelper.defaults.error('Error: Cannot use --unconfigured with a specific flag name. --unconfigured works with multiple flags.');
+            return false;
+        }
+        return true;
+    }
+    /** Validates that --set operations have required accompanying options */
+    async validateSetWithFlags(params) {
+        if (params.set && params.FLAGNAME && !params.value) {
+            await this.ioHelper.defaults.error('Error: When setting a specific flag, you must provide a --value.');
+            return false;
+        }
+        if (params.set && params.all && !params.recommended && !params.default) {
+            await this.ioHelper.defaults.error('Error: When using --set with --all, you must specify either --recommended or --default.');
+            return false;
+        }
+        if (params.set && params.unconfigured && !params.recommended && !params.default) {
+            await this.ioHelper.defaults.error('Error: When using --set with --unconfigured, you must specify either --recommended or --default.');
+            return false;
+        }
+        if (params.set && !params.all && !params.unconfigured && !params.FLAGNAME) {
+            await this.ioHelper.defaults.error('Error: When using --set, you must specify either --all, --unconfigured, or provide a specific flag name.');
+            return false;
+        }
+        return true;
+    }
+}
+exports.FlagValidator = FlagValidator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validator.js","sourceRoot":"","sources":["validator.ts"],"names":[],"mappings":"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","sourcesContent":["import type { FlagOperationsParams } from './types';\nimport type { IoHelper } from '../../api-private';\n\nexport class FlagValidator {\n  constructor(private readonly ioHelper: IoHelper) {\n  }\n\n  /** Shows error message when CDK version is incompatible with flags command */\n  async showIncompatibleVersionError(): Promise<void> {\n    await this.ioHelper.defaults.error('The \\'cdk flags\\' command is not compatible with the AWS CDK library used by your application. Please upgrade to 2.212.0 or above.');\n  }\n\n  /** Validates all parameters and returns true if valid, false if any validation fails */\n  async validateParams(params: FlagOperationsParams): Promise<boolean> {\n    const validations = [\n      () => this.validateFlagNameAndAll(params),\n      () => this.validateSetRequirement(params),\n      () => this.validateValueRequirement(params),\n      () => this.validateMutuallyExclusive(params),\n      () => this.validateUnconfiguredUsage(params),\n      () => this.validateSetWithFlags(params),\n    ];\n\n    for (const validation of validations) {\n      const isValid = await validation();\n      if (!isValid) return false;\n    }\n    return true;\n  }\n\n  /** Validates that --all and specific flag names are not used together */\n  private async validateFlagNameAndAll(params: FlagOperationsParams): Promise<boolean> {\n    if (params.FLAGNAME && params.all) {\n      await this.ioHelper.defaults.error('Error: Cannot use both --all and a specific flag name. Please use either --all to show all flags or specify a single flag name.');\n      return false;\n    }\n    return true;\n  }\n\n  /** Validates that modification options require --set flag */\n  private async validateSetRequirement(params: FlagOperationsParams): Promise<boolean> {\n    if ((params.value || params.recommended || params.default || params.unconfigured) && !params.set) {\n      await this.ioHelper.defaults.error('Error: This option can only be used with --set.');\n      return false;\n    }\n    return true;\n  }\n\n  /** Validates that --value requires a specific flag name */\n  private async validateValueRequirement(params: FlagOperationsParams): Promise<boolean> {\n    if (params.value && !params.FLAGNAME) {\n      await this.ioHelper.defaults.error('Error: --value requires a specific flag name. Please specify a flag name when providing a value.');\n      return false;\n    }\n    return true;\n  }\n\n  /** Validates that mutually exclusive options are not used together */\n  private async validateMutuallyExclusive(params: FlagOperationsParams): Promise<boolean> {\n    if (params.recommended && params.default) {\n      await this.ioHelper.defaults.error('Error: Cannot use both --recommended and --default. Please choose one option.');\n      return false;\n    }\n    if (params.unconfigured && params.all) {\n      await this.ioHelper.defaults.error('Error: Cannot use both --unconfigured and --all. Please choose one option.');\n      return false;\n    }\n    return true;\n  }\n\n  /** Validates that --unconfigured is not used with specific flag names */\n  private async validateUnconfiguredUsage(params: FlagOperationsParams): Promise<boolean> {\n    if (params.unconfigured && params.FLAGNAME) {\n      await this.ioHelper.defaults.error('Error: Cannot use --unconfigured with a specific flag name. --unconfigured works with multiple flags.');\n      return false;\n    }\n    return true;\n  }\n\n  /** Validates that --set operations have required accompanying options */\n  private async validateSetWithFlags(params: FlagOperationsParams): Promise<boolean> {\n    if (params.set && params.FLAGNAME && !params.value) {\n      await this.ioHelper.defaults.error('Error: When setting a specific flag, you must provide a --value.');\n      return false;\n    }\n    if (params.set && params.all && !params.recommended && !params.default) {\n      await this.ioHelper.defaults.error('Error: When using --set with --all, you must specify either --recommended or --default.');\n      return false;\n    }\n    if (params.set && params.unconfigured && !params.recommended && !params.default) {\n      await this.ioHelper.defaults.error('Error: When using --set with --unconfigured, you must specify either --recommended or --default.');\n      return false;\n    }\n    if (params.set && !params.all && !params.unconfigured && !params.FLAGNAME) {\n      await this.ioHelper.defaults.error('Error: When using --set, you must specify either --all, --unconfigured, or provide a specific flag name.');\n      return false;\n    }\n    return true;\n  }\n}\n"]}

package/lib/commands/init/index.d.ts

@@ -0,0 +1 @@
+export * from './init';

package/lib/commands/init/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./init"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseUNBQXVCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9pbml0JztcbiJdfQ==

package/lib/commands/init/init-hooks.d.ts

@@ -0,0 +1,41 @@
+import type { IoHelper } from '../../api-private';
+export type SubstitutePlaceholders = (...fileNames: string[]) => Promise<void>;
+/**
+ * Helpers passed to hook functions
+ */
+export interface HookContext {
+    /**
+     * Callback function to replace placeholders on arbitrary files
+     *
+     * This makes token substitution available to non-`.template` files.
+     */
+    readonly substitutePlaceholdersIn: SubstitutePlaceholders;
+    /**
+     * Return a single placeholder
+     */
+    placeholder(name: string): string;
+}
+export type InvokeHook = (targetDirectory: string, context: HookContext) => Promise<void>;
+export interface HookTarget {
+    readonly targetDirectory: string;
+    readonly templateName: string;
+    readonly language: string;
+}
+/**
+ * Invoke hooks for the given init template
+ *
+ * Sometimes templates need more complex logic than just replacing tokens. A 'hook' can be
+ * used to do additional processing other than copying files.
+ *
+ * Hooks used to be defined externally to the CLI, by running arbitrarily
+ * substituted shell scripts in the target directory.
+ *
+ * In practice, they're all TypeScript files and all the same, and the dynamism
+ * that the original solution allowed wasn't used at all. Worse, since the CLI
+ * is now bundled the hooks can't even reuse code from the CLI libraries at all
+ * anymore, so all shared code would have to be copy/pasted.
+ *
+ * Bundle hooks as built-ins into the CLI, so they get bundled and can take advantage
+ * of all shared code.
+ */
+export declare function invokeBuiltinHooks(ioHelper: IoHelper, target: HookTarget, context: HookContext): Promise<void>;

package/lib/commands/init/init-hooks.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeBuiltinHooks = invokeBuiltinHooks;
+const path = require("path");
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+const os_1 = require("./os");
+const util_1 = require("../../util");
+/**
+ * Invoke hooks for the given init template
+ *
+ * Sometimes templates need more complex logic than just replacing tokens. A 'hook' can be
+ * used to do additional processing other than copying files.
+ *
+ * Hooks used to be defined externally to the CLI, by running arbitrarily
+ * substituted shell scripts in the target directory.
+ *
+ * In practice, they're all TypeScript files and all the same, and the dynamism
+ * that the original solution allowed wasn't used at all. Worse, since the CLI
+ * is now bundled the hooks can't even reuse code from the CLI libraries at all
+ * anymore, so all shared code would have to be copy/pasted.
+ *
+ * Bundle hooks as built-ins into the CLI, so they get bundled and can take advantage
+ * of all shared code.
+ */
+async function invokeBuiltinHooks(ioHelper, target, context) {
+    switch (target.language) {
+        case 'csharp':
+            if (['app', 'sample-app'].includes(target.templateName)) {
+                return dotnetAddProject(ioHelper, target.targetDirectory, context);
+            }
+            break;
+        case 'fsharp':
+            if (['app', 'sample-app'].includes(target.templateName)) {
+                return dotnetAddProject(ioHelper, target.targetDirectory, context, 'fsproj');
+            }
+            break;
+        case 'python':
+            // We can't call this file 'requirements.template.txt' because Dependabot needs to be able to find it.
+            // Therefore, keep the in-repo name but still substitute placeholders.
+            await context.substitutePlaceholdersIn('requirements.txt');
+            break;
+        case 'java':
+            // We can't call this file 'pom.template.xml'... for the same reason as Python above.
+            await context.substitutePlaceholdersIn('pom.xml');
+            break;
+        case 'javascript':
+        case 'typescript':
+            // See above, but for 'package.json'.
+            await context.substitutePlaceholdersIn('package.json', 'README.md');
+    }
+}
+async function dotnetAddProject(ioHelper, targetDirectory, context, ext = 'csproj') {
+    const pname = context.placeholder('name.PascalCased');
+    const slnPath = path.join(targetDirectory, 'src', `${pname}.sln`);
+    const csprojPath = path.join(targetDirectory, 'src', pname, `${pname}.${ext}`);
+    // We retry this command a couple of times. It usually never fails, except on CI where
+    // we sometimes see:
+    //
+    //   System.IO.IOException: The system cannot open the device or file specified. : 'NuGet-Migrations'
+    //
+    // This error can be caused by lack of permissions on a temporary directory,
+    // but in our case it's intermittent so my guess is it is caused by multiple
+    // invocations of the .NET CLI running in parallel, and trampling on each
+    // other creating a Mutex. There is no fix, and it is annoyingly breaking our
+    // CI regularly. Retry a couple of times to increase reliability.
+    //
+    // - https://github.com/dotnet/sdk/issues/43750
+    // - https://github.com/dotnet/runtime/issues/80619
+    // - https://github.com/dotnet/runtime/issues/91987
+    const MAX_ATTEMPTS = 3;
+    for (let attempt = 1;; attempt++) {
+        try {
+            await (0, os_1.shell)(ioHelper, ['dotnet', 'sln', slnPath, 'add', csprojPath]);
+            return;
+        }
+        catch (e) {
+            if (attempt === MAX_ATTEMPTS) {
+                throw new toolkit_lib_1.ToolkitError('DotnetSlnAddFailed', `Could not add project ${pname}.${ext} to solution ${pname}.sln. ${(0, util_1.formatErrorMessage)(e)}`);
+            }
+            // Sleep for a bit then try again
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"init-hooks.js","sourceRoot":"","sources":["init-hooks.ts"],"names":[],"mappings":";;AAkDA,gDA8BC;AAhFD,6BAA6B;AAC7B,sDAAoD;AACpD,6BAA6B;AAE7B,qCAAgD;AA6BhD;;;;;;;;;;;;;;;;GAgBG;AACI,KAAK,UAAU,kBAAkB,CAAC,QAAkB,EAAE,MAAkB,EAAE,OAAoB;IACnG,QAAQ,MAAM,CAAC,QAAQ,EAAE,CAAC;QACxB,KAAK,QAAQ;YACX,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC;gBACxD,OAAO,gBAAgB,CAAC,QAAQ,EAAE,MAAM,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;YACrE,CAAC;YACD,MAAM;QAER,KAAK,QAAQ;YACX,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC;gBACxD,OAAO,gBAAgB,CAAC,QAAQ,EAAE,MAAM,CAAC,eAAe,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;YAC/E,CAAC;YACD,MAAM;QAER,KAAK,QAAQ;YACX,sGAAsG;YACtG,sEAAsE;YACtE,MAAM,OAAO,CAAC,wBAAwB,CAAC,kBAAkB,CAAC,CAAC;YAC3D,MAAM;QAER,KAAK,MAAM;YACT,qFAAqF;YACrF,MAAM,OAAO,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC;YAClD,MAAM;QAER,KAAK,YAAY,CAAC;QAClB,KAAK,YAAY;YACf,qCAAqC;YACrC,MAAM,OAAO,CAAC,wBAAwB,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;IACxE,CAAC;AACH,CAAC;AAED,KAAK,UAAU,gBAAgB,CAAC,QAAkB,EAAE,eAAuB,EAAE,OAAoB,EAAE,GAAG,GAAG,QAAQ;IAC/G,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,kBAAkB,CAAC,CAAC;IACtD,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,GAAG,KAAK,MAAM,CAAC,CAAC;IAClE,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,GAAG,EAAE,CAAC,CAAC;IAE/E,sFAAsF;IACtF,oBAAoB;IACpB,EAAE;IACF,qGAAqG;IACrG,EAAE;IACF,4EAA4E;IAC5E,4EAA4E;IAC5E,yEAAyE;IACzE,6EAA6E;IAC7E,iEAAiE;IACjE,EAAE;IACF,+CAA+C;IAC/C,mDAAmD;IACnD,mDAAmD;IACnD,MAAM,YAAY,GAAG,CAAC,CAAC;IACvB,KAAK,IAAI,OAAO,GAAG,CAAC,GAAI,OAAO,EAAE,EAAE,CAAC;QAClC,IAAI,CAAC;YACH,MAAM,IAAA,UAAK,EAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;YACrE,OAAO;QACT,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,IAAI,OAAO,KAAK,YAAY,EAAE,CAAC;gBAC7B,MAAM,IAAI,0BAAY,CAAC,oBAAoB,EAAE,yBAAyB,KAAK,IAAI,GAAG,gBAAgB,KAAK,SAAS,IAAA,yBAAkB,EAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAC3I,CAAC;YAED,iCAAiC;YACjC,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;QAC1D,CAAC;IACH,CAAC;AACH,CAAC","sourcesContent":["import * as path from 'path';\nimport { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport { shell } from './os';\nimport type { IoHelper } from '../../api-private';\nimport { formatErrorMessage } from '../../util';\n\nexport type SubstitutePlaceholders = (...fileNames: string[]) => Promise<void>;\n\n/**\n * Helpers passed to hook functions\n */\nexport interface HookContext {\n  /**\n   * Callback function to replace placeholders on arbitrary files\n   *\n   * This makes token substitution available to non-`.template` files.\n   */\n  readonly substitutePlaceholdersIn: SubstitutePlaceholders;\n\n  /**\n   * Return a single placeholder\n   */\n  placeholder(name: string): string;\n}\n\nexport type InvokeHook = (targetDirectory: string, context: HookContext) => Promise<void>;\n\nexport interface HookTarget {\n  readonly targetDirectory: string;\n  readonly templateName: string;\n  readonly language: string;\n}\n\n/**\n * Invoke hooks for the given init template\n *\n * Sometimes templates need more complex logic than just replacing tokens. A 'hook' can be\n * used to do additional processing other than copying files.\n *\n * Hooks used to be defined externally to the CLI, by running arbitrarily\n * substituted shell scripts in the target directory.\n *\n * In practice, they're all TypeScript files and all the same, and the dynamism\n * that the original solution allowed wasn't used at all. Worse, since the CLI\n * is now bundled the hooks can't even reuse code from the CLI libraries at all\n * anymore, so all shared code would have to be copy/pasted.\n *\n * Bundle hooks as built-ins into the CLI, so they get bundled and can take advantage\n * of all shared code.\n */\nexport async function invokeBuiltinHooks(ioHelper: IoHelper, target: HookTarget, context: HookContext) {\n  switch (target.language) {\n    case 'csharp':\n      if (['app', 'sample-app'].includes(target.templateName)) {\n        return dotnetAddProject(ioHelper, target.targetDirectory, context);\n      }\n      break;\n\n    case 'fsharp':\n      if (['app', 'sample-app'].includes(target.templateName)) {\n        return dotnetAddProject(ioHelper, target.targetDirectory, context, 'fsproj');\n      }\n      break;\n\n    case 'python':\n      // We can't call this file 'requirements.template.txt' because Dependabot needs to be able to find it.\n      // Therefore, keep the in-repo name but still substitute placeholders.\n      await context.substitutePlaceholdersIn('requirements.txt');\n      break;\n\n    case 'java':\n      // We can't call this file 'pom.template.xml'... for the same reason as Python above.\n      await context.substitutePlaceholdersIn('pom.xml');\n      break;\n\n    case 'javascript':\n    case 'typescript':\n      // See above, but for 'package.json'.\n      await context.substitutePlaceholdersIn('package.json', 'README.md');\n  }\n}\n\nasync function dotnetAddProject(ioHelper: IoHelper, targetDirectory: string, context: HookContext, ext = 'csproj') {\n  const pname = context.placeholder('name.PascalCased');\n  const slnPath = path.join(targetDirectory, 'src', `${pname}.sln`);\n  const csprojPath = path.join(targetDirectory, 'src', pname, `${pname}.${ext}`);\n\n  // We retry this command a couple of times. It usually never fails, except on CI where\n  // we sometimes see:\n  //\n  //   System.IO.IOException: The system cannot open the device or file specified. : 'NuGet-Migrations'\n  //\n  // This error can be caused by lack of permissions on a temporary directory,\n  // but in our case it's intermittent so my guess is it is caused by multiple\n  // invocations of the .NET CLI running in parallel, and trampling on each\n  // other creating a Mutex. There is no fix, and it is annoyingly breaking our\n  // CI regularly. Retry a couple of times to increase reliability.\n  //\n  // - https://github.com/dotnet/sdk/issues/43750\n  // - https://github.com/dotnet/runtime/issues/80619\n  // - https://github.com/dotnet/runtime/issues/91987\n  const MAX_ATTEMPTS = 3;\n  for (let attempt = 1; ; attempt++) {\n    try {\n      await shell(ioHelper, ['dotnet', 'sln', slnPath, 'add', csprojPath]);\n      return;\n    } catch (e: any) {\n      if (attempt === MAX_ATTEMPTS) {\n        throw new ToolkitError('DotnetSlnAddFailed', `Could not add project ${pname}.${ext} to solution ${pname}.sln. ${formatErrorMessage(e)}`);\n      }\n\n      // Sleep for a bit then try again\n      await new Promise(resolve => setTimeout(resolve, 1000));\n    }\n  }\n}\n"]}

package/lib/commands/init/init.d.ts

@@ -0,0 +1,139 @@
+import type { IoHelper } from '../../api-private';
+import { type JsPackageManager } from './package-manager';
+export interface CliInitOptions {
+    /**
+     * Template name to initialize
+     * @default undefined
+     */
+    readonly type?: string;
+    /**
+     * Programming language for the project
+     * @default - Optional/auto-detected if template supports only one language, otherwise required
+     */
+    readonly language?: string;
+    /**
+     * @default true
+     */
+    readonly canUseNetwork?: boolean;
+    /**
+     * @default false
+     */
+    readonly generateOnly?: boolean;
+    /**
+     * @default process.cwd()
+     */
+    readonly workDir?: string;
+    /**
+     * @default undefined
+     */
+    readonly projectName?: string;
+    /**
+     * @default undefined
+     */
+    readonly stackName?: string;
+    /**
+     * @default undefined
+     */
+    readonly migrate?: boolean;
+    /**
+     * Override the built-in CDK version
+     * @default undefined
+     */
+    readonly libVersion?: string;
+    /**
+     * Path to a local custom template directory
+     * @default undefined
+     */
+    readonly fromPath?: string;
+    /**
+     * Path to a specific template within a multi-template repository.
+     * This parameter requires --from-path to be specified.
+     * @default undefined
+     */
+    readonly templatePath?: string;
+    /**
+     * The package manager to use for installing dependencies. Only applicable for TypeScript and JavaScript projects.
+     * @default - If specified language is 'typescript' or 'javascript', 'npm' is selected. Otherwise, no package manager is used.
+     */
+    readonly packageManager?: JsPackageManager;
+    readonly ioHelper: IoHelper;
+}
+/**
+ * Initialize a CDK package in the current directory
+ */
+export declare function cliInit(options: CliInitOptions): Promise<void>;
+interface TemplateInitInfo {
+    readonly description: string;
+    readonly aliases?: string[];
+}
+declare enum TemplateType {
+    BUILT_IN = "builtin",
+    CUSTOM = "custom"
+}
+export declare class InitTemplate {
+    private readonly basePath;
+    readonly name: string;
+    readonly languages: string[];
+    static fromName(templatesDir: string, name: string): Promise<InitTemplate>;
+    static fromPath(templatePath: string): Promise<InitTemplate>;
+    readonly description?: string;
+    readonly aliases: Set<string>;
+    readonly templateType: TemplateType;
+    constructor(basePath: string, name: string, languages: string[], initInfo: TemplateInitInfo | null, templateType: TemplateType);
+    /**
+     * @param name - the name that is being checked
+     * @returns ``true`` if ``name`` is the name of this template or an alias of it.
+     */
+    hasName(name: string): boolean;
+    /**
+     * Creates a new instance of this ``InitTemplate`` for a given language to a specified folder.
+     *
+     * @param language - the language to instantiate this template with
+     * @param targetDirectory - the directory where the template is to be instantiated into
+     * @param stackName - the name of the stack to create
+     * @default undefined
+     * @param libVersion - the version of the CDK library to use
+     * @default undefined
+     */
+    install(ioHelper: IoHelper, language: string, targetDirectory: string, projectName?: string, stackName?: string, libVersion?: string, packageManager?: JsPackageManager): Promise<void>;
+    private installFiles;
+    private installProcessed;
+    /**
+     * Copy template files without processing placeholders (for custom templates)
+     */
+    private installFilesWithoutProcessing;
+    /**
+     * Adds context variables to `cdk.json` in the generated project directory to
+     * enable future behavior for new projects.
+     */
+    private applyFutureFlags;
+    addMigrateContext(projectDir: string): Promise<void>;
+}
+export declare function expandPlaceholders(template: string, language: string, project: ProjectInfo, packageManager?: JsPackageManager): string;
+interface ProjectInfo {
+    /** The value used for %name% */
+    readonly name: string;
+    readonly stackName?: string;
+    readonly versions: Versions;
+}
+export declare function availableInitTemplates(): Promise<InitTemplate[]>;
+export declare function availableInitLanguages(): Promise<string[]>;
+/**
+ * Print available templates to the user
+ * @param ioHelper - IO helper for user interaction
+ * @param language - Programming language filter
+ * @default undefined
+ */
+export declare function printAvailableTemplates(ioHelper: IoHelper, language?: string): Promise<void>;
+interface Versions {
+    ['aws-cdk']: string;
+    ['aws-cdk-lib']: string;
+    constructs: string;
+}
+/**
+ * Return the currently recommended flags for `aws-cdk-lib`.
+ *
+ * These have been built into the CLI at build time.
+ */
+export declare function currentlyRecommendedAwsCdkLibFlags(): Promise<any>;
+export {};