@aws-cdk-testing/cli-integ 2.61.0

package/lib/aws.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = exports.outputFromStack = exports.retry = exports.isBucketMissingError = exports.isStackMissingError = exports.AwsClients = void 0;
+const AWS = require("aws-sdk");
+class AwsClients {
+    constructor(region, output) {
+        this.region = region;
+        this.output = output;
+        this.config = {
+            credentials: chainableCredentials(this.region),
+            region: this.region,
+            maxRetries: 8,
+            retryDelayOptions: { base: 500 },
+            stsRegionalEndpoints: 'regional',
+        };
+        this.cloudFormation = makeAwsCaller(AWS.CloudFormation, this.config);
+        this.s3 = makeAwsCaller(AWS.S3, this.config);
+        this.ecr = makeAwsCaller(AWS.ECR, this.config);
+        this.sns = makeAwsCaller(AWS.SNS, this.config);
+        this.iam = makeAwsCaller(AWS.IAM, this.config);
+        this.lambda = makeAwsCaller(AWS.Lambda, this.config);
+        this.sts = makeAwsCaller(AWS.STS, this.config);
+    }
+    static async default(output) {
+        const region = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1';
+        return AwsClients.forRegion(region, output);
+    }
+    static async forRegion(region, output) {
+        return new AwsClients(region, output);
+    }
+    async account() {
+        // Reduce # of retries, we use this as a circuit breaker for detecting no-config
+        return (await new AWS.STS({ ...this.config, maxRetries: 1 }).getCallerIdentity().promise()).Account;
+    }
+    async deleteStacks(...stackNames) {
+        if (stackNames.length === 0) {
+            return;
+        }
+        // We purposely do all stacks serially, because they've been ordered
+        // to do the bootstrap stack last.
+        for (const stackName of stackNames) {
+            await this.cloudFormation('updateTerminationProtection', {
+                EnableTerminationProtection: false,
+                StackName: stackName,
+            });
+            await this.cloudFormation('deleteStack', {
+                StackName: stackName,
+            });
+            await retry(this.output, `Deleting ${stackName}`, retry.forSeconds(600), async () => {
+                const status = await this.stackStatus(stackName);
+                if (status !== undefined && status.endsWith('_FAILED')) {
+                    throw retry.abort(new Error(`'${stackName}' is in state '${status}'`));
+                }
+                if (status !== undefined) {
+                    throw new Error(`Delete of '${stackName}' not complete yet`);
+                }
+            });
+        }
+    }
+    async stackStatus(stackName) {
+        try {
+            return (await this.cloudFormation('describeStacks', { StackName: stackName })).Stacks?.[0].StackStatus;
+        }
+        catch (e) {
+            if (isStackMissingError(e)) {
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    async emptyBucket(bucketName) {
+        const objects = await this.s3('listObjectVersions', { Bucket: bucketName });
+        const deletes = [...objects.Versions || [], ...objects.DeleteMarkers || []]
+            .reduce((acc, obj) => {
+            if (typeof obj.VersionId !== 'undefined' && typeof obj.Key !== 'undefined') {
+                acc.push({ Key: obj.Key, VersionId: obj.VersionId });
+            }
+            else if (typeof obj.Key !== 'undefined') {
+                acc.push({ Key: obj.Key });
+            }
+            return acc;
+        }, []);
+        if (deletes.length === 0) {
+            return Promise.resolve();
+        }
+        return this.s3('deleteObjects', {
+            Bucket: bucketName,
+            Delete: {
+                Objects: deletes,
+                Quiet: false,
+            },
+        });
+    }
+    async deleteImageRepository(repositoryName) {
+        await this.ecr('deleteRepository', { repositoryName, force: true });
+    }
+    async deleteBucket(bucketName) {
+        try {
+            await this.emptyBucket(bucketName);
+            await this.s3('deleteBucket', {
+                Bucket: bucketName,
+            });
+        }
+        catch (e) {
+            if (isBucketMissingError(e)) {
+                return;
+            }
+            throw e;
+        }
+    }
+}
+exports.AwsClients = AwsClients;
+/**
+ * Perform an AWS call from nothing
+ *
+ * Create the correct client, do the call and resole the promise().
+ */
+async function awsCall(ctor, config, call, request) {
+    const cfn = new ctor(config);
+    const response = cfn[call](request);
+    try {
+        return response.promise();
+    }
+    catch (e) {
+        const newErr = new Error(`${call}(${JSON.stringify(request)}): ${e.message}`);
+        newErr.code = e.code;
+        throw newErr;
+    }
+}
+/**
+ * Factory function to invoke 'awsCall' for specific services.
+ *
+ * Not strictly necessary but calling this replaces a whole bunch of annoying generics you otherwise have to type:
+ *
+ * ```ts
+ * export function cloudFormation<
+ *   C extends keyof ServiceCalls<AWS.CloudFormation>,
+ * >(call: C, request: First<ServiceCalls<AWS.CloudFormation>[C]>): Promise<Second<ServiceCalls<AWS.CloudFormation>[C]>> {
+ *   return awsCall(AWS.CloudFormation, call, request);
+ * }
+ * ```
+ */
+function makeAwsCaller(ctor, config) {
+    return (call, request) => {
+        return awsCall(ctor, config, call, request);
+    };
+}
+function isStackMissingError(e) {
+    return e.message.indexOf('does not exist') > -1;
+}
+exports.isStackMissingError = isStackMissingError;
+function isBucketMissingError(e) {
+    return e.message.indexOf('does not exist') > -1;
+}
+exports.isBucketMissingError = isBucketMissingError;
+/**
+ * Retry an async operation until a deadline is hit.
+ *
+ * Use `retry.forSeconds()` to construct a deadline relative to right now.
+ *
+ * Exceptions will cause the operation to retry. Use `retry.abort` to annotate an exception
+ * to stop the retry and end in a failure.
+ */
+async function retry(output, operation, deadline, block) {
+    let i = 0;
+    output.write(`💈 ${operation}\n`);
+    while (true) {
+        try {
+            i++;
+            const ret = await block();
+            output.write(`💈 ${operation}: succeeded after ${i} attempts\n`);
+            return ret;
+        }
+        catch (e) {
+            if (e.abort || Date.now() > deadline.getTime()) {
+                throw new Error(`${operation}: did not succeed after ${i} attempts: ${e}`);
+            }
+            output.write(`⏳ ${operation} (${e.message})\n`);
+            await sleep(5000);
+        }
+    }
+}
+exports.retry = retry;
+/**
+ * Make a deadline for the `retry` function relative to the current time.
+ */
+retry.forSeconds = (seconds) => {
+    return new Date(Date.now() + seconds * 1000);
+};
+/**
+ * Annotate an error to stop the retrying
+ */
+retry.abort = (e) => {
+    e.abort = true;
+    return e;
+};
+function outputFromStack(key, stack) {
+    return (stack.Outputs ?? []).find(o => o.OutputKey === key)?.OutputValue;
+}
+exports.outputFromStack = outputFromStack;
+async function sleep(ms) {
+    return new Promise(ok => setTimeout(ok, ms));
+}
+exports.sleep = sleep;
+function chainableCredentials(region) {
+    const profileName = process.env.AWS_PROFILE;
+    if (process.env.CODEBUILD_BUILD_ARN && profileName) {
+        // in codebuild we must assume the role that the cdk uses
+        // otherwise credentials will just be picked up by the normal sdk
+        // heuristics and expire after an hour.
+        // can't use '~' since the SDK doesn't seem to expand it...?
+        const configPath = `${process.env.HOME}/.aws/config`;
+        const ini = new AWS.IniLoader().loadFrom({
+            filename: configPath,
+            isConfig: true,
+        });
+        const profile = ini[profileName];
+        if (!profile) {
+            throw new Error(`Profile '${profileName}' does not exist in config file (${configPath})`);
+        }
+        const arn = profile.role_arn;
+        const externalId = profile.external_id;
+        if (!arn) {
+            throw new Error(`role_arn does not exist in profile ${profileName}`);
+        }
+        if (!externalId) {
+            throw new Error(`external_id does not exist in profile ${externalId}`);
+        }
+        return new AWS.ChainableTemporaryCredentials({
+            params: {
+                RoleArn: arn,
+                ExternalId: externalId,
+                RoleSessionName: 'integ-tests',
+            },
+            stsConfig: {
+                region,
+            },
+            masterCredentials: new AWS.ECSCredentials(),
+        });
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws.js","sourceRoot":"","sources":["aws.ts"],"names":[],"mappings":"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","sourcesContent":["import * as AWS from 'aws-sdk';\n\nexport class AwsClients {\n  public static async default(output: NodeJS.WritableStream) {\n    const region = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1';\n    return AwsClients.forRegion(region, output);\n  }\n\n  public static async forRegion(region: string, output: NodeJS.WritableStream) {\n    return new AwsClients(region, output);\n  }\n\n  private readonly config: any;\n\n  public readonly cloudFormation: AwsCaller<AWS.CloudFormation>;\n  public readonly s3: AwsCaller<AWS.S3>;\n  public readonly ecr: AwsCaller<AWS.ECR>;\n  public readonly sns: AwsCaller<AWS.SNS>;\n  public readonly iam: AwsCaller<AWS.IAM>;\n  public readonly lambda: AwsCaller<AWS.Lambda>;\n  public readonly sts: AwsCaller<AWS.STS>;\n\n  constructor(public readonly region: string, private readonly output: NodeJS.WritableStream) {\n    this.config = {\n      credentials: chainableCredentials(this.region),\n      region: this.region,\n      maxRetries: 8,\n      retryDelayOptions: { base: 500 },\n      stsRegionalEndpoints: 'regional',\n    };\n    this.cloudFormation = makeAwsCaller(AWS.CloudFormation, this.config);\n    this.s3 = makeAwsCaller(AWS.S3, this.config);\n    this.ecr = makeAwsCaller(AWS.ECR, this.config);\n    this.sns = makeAwsCaller(AWS.SNS, this.config);\n    this.iam = makeAwsCaller(AWS.IAM, this.config);\n    this.lambda = makeAwsCaller(AWS.Lambda, this.config);\n    this.sts = makeAwsCaller(AWS.STS, this.config);\n  }\n\n  public async account(): Promise<string> {\n    // Reduce # of retries, we use this as a circuit breaker for detecting no-config\n    return (await new AWS.STS({ ...this.config, maxRetries: 1 }).getCallerIdentity().promise()).Account!;\n  }\n\n  public async deleteStacks(...stackNames: string[]) {\n    if (stackNames.length === 0) { return; }\n\n    // We purposely do all stacks serially, because they've been ordered\n    // to do the bootstrap stack last.\n    for (const stackName of stackNames) {\n      await this.cloudFormation('updateTerminationProtection', {\n        EnableTerminationProtection: false,\n        StackName: stackName,\n      });\n      await this.cloudFormation('deleteStack', {\n        StackName: stackName,\n      });\n\n      await retry(this.output, `Deleting ${stackName}`, retry.forSeconds(600), async () => {\n        const status = await this.stackStatus(stackName);\n        if (status !== undefined && status.endsWith('_FAILED')) {\n          throw retry.abort(new Error(`'${stackName}' is in state '${status}'`));\n        }\n        if (status !== undefined) {\n          throw new Error(`Delete of '${stackName}' not complete yet`);\n        }\n      });\n    }\n  }\n\n  public async stackStatus(stackName: string): Promise<string | undefined> {\n    try {\n      return (await this.cloudFormation('describeStacks', { StackName: stackName })).Stacks?.[0].StackStatus;\n    } catch (e) {\n      if (isStackMissingError(e)) { return undefined; }\n      throw e;\n    }\n  }\n\n  public async emptyBucket(bucketName: string) {\n    const objects = await this.s3('listObjectVersions', { Bucket: bucketName });\n    const deletes = [...objects.Versions || [], ...objects.DeleteMarkers || []]\n      .reduce((acc, obj) => {\n        if (typeof obj.VersionId !== 'undefined' && typeof obj.Key !== 'undefined') {\n          acc.push({ Key: obj.Key, VersionId: obj.VersionId });\n        } else if (typeof obj.Key !== 'undefined') {\n          acc.push({ Key: obj.Key });\n        }\n        return acc;\n      }, [] as AWS.S3.ObjectIdentifierList);\n    if (deletes.length === 0) {\n      return Promise.resolve();\n    }\n    return this.s3('deleteObjects', {\n      Bucket: bucketName,\n      Delete: {\n        Objects: deletes,\n        Quiet: false,\n      },\n    });\n  }\n\n  public async deleteImageRepository(repositoryName: string) {\n    await this.ecr('deleteRepository', { repositoryName, force: true });\n  }\n\n  public async deleteBucket(bucketName: string) {\n    try {\n      await this.emptyBucket(bucketName);\n      await this.s3('deleteBucket', {\n        Bucket: bucketName,\n      });\n    } catch (e) {\n      if (isBucketMissingError(e)) { return; }\n      throw e;\n    }\n  }\n}\n\n/**\n * Perform an AWS call from nothing\n *\n * Create the correct client, do the call and resole the promise().\n */\nasync function awsCall<\n  A extends AWS.Service,\n  B extends keyof ServiceCalls<A>,\n>(ctor: new (config: any) => A, config: any, call: B, request: First<ServiceCalls<A>[B]>): Promise<Second<ServiceCalls<A>[B]>> {\n  const cfn = new ctor(config);\n  const response = cfn[call](request);\n  try {\n    return response.promise();\n  } catch (e) {\n    const newErr = new Error(`${call}(${JSON.stringify(request)}): ${e.message}`);\n    (newErr as any).code = e.code;\n    throw newErr;\n  }\n}\n\ntype AwsCaller<A> = <B extends keyof ServiceCalls<A>>(call: B, request: First<ServiceCalls<A>[B]>) => Promise<Second<ServiceCalls<A>[B]>>;\n\n/**\n * Factory function to invoke 'awsCall' for specific services.\n *\n * Not strictly necessary but calling this replaces a whole bunch of annoying generics you otherwise have to type:\n *\n * ```ts\n * export function cloudFormation<\n *   C extends keyof ServiceCalls<AWS.CloudFormation>,\n * >(call: C, request: First<ServiceCalls<AWS.CloudFormation>[C]>): Promise<Second<ServiceCalls<AWS.CloudFormation>[C]>> {\n *   return awsCall(AWS.CloudFormation, call, request);\n * }\n * ```\n */\nfunction makeAwsCaller<A extends AWS.Service>(ctor: new (config: any) => A, config: any): AwsCaller<A> {\n  return <B extends keyof ServiceCalls<A>>(call: B, request: First<ServiceCalls<A>[B]>): Promise<Second<ServiceCalls<A>[B]>> => {\n    return awsCall(ctor, config, call, request);\n  };\n}\n\ntype ServiceCalls<T> = NoNayNever<SimplifiedService<T>>;\n// Map ever member in the type to the important AWS call overload, or to 'never'\ntype SimplifiedService<T> = {[k in keyof T]: AwsCallIO<T[k]>};\n// Remove all 'never' types from an object type\ntype NoNayNever<T> = Pick<T, {[k in keyof T]: T[k] extends never ? never : k }[keyof T]>;\n\n// Because of the overloads an AWS handler type looks like this:\n//\n//   {\n//      (params: INPUTSTRUCT, callback?: ((err: AWSError, data: {}) => void) | undefined): Request<OUTPUT, ...>;\n//      (callback?: ((err: AWS.AWSError, data: {}) => void) | undefined): AWS.Request<...>;\n//   }\n//\n// Get the first overload and extract the input and output struct types\ntype AwsCallIO<T> =\n  T extends {\n    (args: infer INPUT, callback?: ((err: AWS.AWSError, data: any) => void) | undefined): AWS.Request<infer OUTPUT, AWS.AWSError>;\n    (callback?: ((err: AWS.AWSError, data: {}) => void) | undefined): AWS.Request<any, any>;\n  } ? [INPUT, OUTPUT] : never;\n\ntype First<T> = T extends [any, any] ? T[0] : never;\ntype Second<T> = T extends [any, any] ? T[1] : never;\n\n\nexport function isStackMissingError(e: Error) {\n  return e.message.indexOf('does not exist') > -1;\n}\n\nexport function isBucketMissingError(e: Error) {\n  return e.message.indexOf('does not exist') > -1;\n}\n\n/**\n * Retry an async operation until a deadline is hit.\n *\n * Use `retry.forSeconds()` to construct a deadline relative to right now.\n *\n * Exceptions will cause the operation to retry. Use `retry.abort` to annotate an exception\n * to stop the retry and end in a failure.\n */\nexport async function retry<A>(output: NodeJS.WritableStream, operation: string, deadline: Date, block: () => Promise<A>): Promise<A> {\n  let i = 0;\n  output.write(`💈 ${operation}\\n`);\n  while (true) {\n    try {\n      i++;\n      const ret = await block();\n      output.write(`💈 ${operation}: succeeded after ${i} attempts\\n`);\n      return ret;\n    } catch (e) {\n      if (e.abort || Date.now() > deadline.getTime( )) {\n        throw new Error(`${operation}: did not succeed after ${i} attempts: ${e}`);\n      }\n      output.write(`⏳ ${operation} (${e.message})\\n`);\n      await sleep(5000);\n    }\n  }\n}\n\n/**\n * Make a deadline for the `retry` function relative to the current time.\n */\nretry.forSeconds = (seconds: number): Date => {\n  return new Date(Date.now() + seconds * 1000);\n};\n\n/**\n * Annotate an error to stop the retrying\n */\nretry.abort = (e: Error): Error => {\n  (e as any).abort = true;\n  return e;\n};\n\nexport function outputFromStack(key: string, stack: AWS.CloudFormation.Stack): string | undefined {\n  return (stack.Outputs ?? []).find(o => o.OutputKey === key)?.OutputValue;\n}\n\nexport async function sleep(ms: number) {\n  return new Promise(ok => setTimeout(ok, ms));\n}\n\nfunction chainableCredentials(region: string): AWS.Credentials | undefined {\n\n  const profileName = process.env.AWS_PROFILE;\n  if (process.env.CODEBUILD_BUILD_ARN && profileName) {\n\n    // in codebuild we must assume the role that the cdk uses\n    // otherwise credentials will just be picked up by the normal sdk\n    // heuristics and expire after an hour.\n\n    // can't use '~' since the SDK doesn't seem to expand it...?\n    const configPath = `${process.env.HOME}/.aws/config`;\n    const ini = new AWS.IniLoader().loadFrom({\n      filename: configPath,\n      isConfig: true,\n    });\n\n    const profile = ini[profileName];\n\n    if (!profile) {\n      throw new Error(`Profile '${profileName}' does not exist in config file (${configPath})`);\n    }\n\n    const arn = profile.role_arn;\n    const externalId = profile.external_id;\n\n    if (!arn) {\n      throw new Error(`role_arn does not exist in profile ${profileName}`);\n    }\n\n    if (!externalId) {\n      throw new Error(`external_id does not exist in profile ${externalId}`);\n    }\n\n    return new AWS.ChainableTemporaryCredentials({\n      params: {\n        RoleArn: arn,\n        ExternalId: externalId,\n        RoleSessionName: 'integ-tests',\n      },\n      stsConfig: {\n        region,\n      },\n      masterCredentials: new AWS.ECSCredentials(),\n    });\n  }\n\n  return undefined;\n}"]}

package/lib/corking.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/**
+ * Routines for corking stdout and stderr
+ */
+import * as stream from 'stream';
+export declare class MemoryStream extends stream.Writable {
+    private parts;
+    _write(chunk: Buffer, _encoding: string, callback: (error?: Error | null) => void): void;
+    buffer(): Buffer;
+    clear(): void;
+    flushTo(strm: NodeJS.WritableStream): Promise<unknown>;
+    toString(): string;
+}

package/lib/corking.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStream = void 0;
+/**
+ * Routines for corking stdout and stderr
+ */
+const stream = require("stream");
+class MemoryStream extends stream.Writable {
+    constructor() {
+        super(...arguments);
+        this.parts = new Array();
+    }
+    _write(chunk, _encoding, callback) {
+        this.parts.push(chunk);
+        callback();
+    }
+    buffer() {
+        return Buffer.concat(this.parts);
+    }
+    clear() {
+        this.parts.splice(0, this.parts.length);
+    }
+    async flushTo(strm) {
+        const flushed = strm.write(this.buffer());
+        if (!flushed) {
+            return new Promise(ok => strm.once('drain', ok));
+        }
+    }
+    toString() {
+        return this.buffer().toString();
+    }
+}
+exports.MemoryStream = MemoryStream;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/files.d.ts

@@ -0,0 +1,15 @@
+export declare function rmFile(filename: string): Promise<void>;
+export declare function addToFile(filename: string, line: string): Promise<void>;
+export declare function writeFile(filename: string, contents: string): Promise<void>;
+export declare function copyDirectoryContents(dir: string, target: string): Promise<void>;
+export declare function findUp(name: string, directory?: string): string | undefined;
+/**
+ * Docker-safe home directory
+ */
+export declare function homeDir(): string;
+export declare function loadLines(filename: string): Promise<string[]>;
+export declare function writeLines(filename: string, lines: string[]): Promise<void>;
+/**
+ * Update a spaceless ini file in place
+ */
+export declare function updateIniKey(lines: string[], key: string, value: string): void;

package/lib/files.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateIniKey = exports.writeLines = exports.loadLines = exports.homeDir = exports.findUp = exports.copyDirectoryContents = exports.writeFile = exports.addToFile = exports.rmFile = void 0;
+const os = require("os");
+const path = require("path");
+const fs = require("fs-extra");
+async function rmFile(filename) {
+    if (await fs.pathExists(filename)) {
+        await fs.unlink(filename);
+    }
+}
+exports.rmFile = rmFile;
+async function addToFile(filename, line) {
+    let contents = await fs.pathExists(filename) ? await fs.readFile(filename, { encoding: 'utf-8' }) : '';
+    if (!contents.endsWith('\n')) {
+        contents += '\n';
+    }
+    contents += line + '\n';
+    await writeFile(filename, contents);
+}
+exports.addToFile = addToFile;
+async function writeFile(filename, contents) {
+    await fs.mkdirp(path.dirname(filename));
+    await fs.writeFile(filename, contents, { encoding: 'utf-8' });
+}
+exports.writeFile = writeFile;
+async function copyDirectoryContents(dir, target) {
+    for (const file of await fs.readdir(path.join(dir), { encoding: 'utf-8' })) {
+        await fs.copyFile(path.join(dir, file), path.join(target, file));
+    }
+}
+exports.copyDirectoryContents = copyDirectoryContents;
+function findUp(name, directory = process.cwd()) {
+    const absoluteDirectory = path.resolve(directory);
+    const file = path.join(directory, name);
+    if (fs.existsSync(file)) {
+        return file;
+    }
+    const { root } = path.parse(absoluteDirectory);
+    if (absoluteDirectory == root) {
+        return undefined;
+    }
+    return findUp(name, path.dirname(absoluteDirectory));
+}
+exports.findUp = findUp;
+/**
+ * Docker-safe home directory
+ */
+function homeDir() {
+    return os.userInfo().homedir ?? os.homedir();
+}
+exports.homeDir = homeDir;
+async function loadLines(filename) {
+    return await fs.pathExists(filename) ? (await fs.readFile(filename, { encoding: 'utf-8' })).trim().split('\n') : [];
+}
+exports.loadLines = loadLines;
+async function writeLines(filename, lines) {
+    // Must end in a newline or our bash script won't read it properly
+    await fs.writeFile(filename, lines.join('\n') + '\n', { encoding: 'utf-8' });
+}
+exports.writeLines = writeLines;
+/**
+ * Update a spaceless ini file in place
+ */
+function updateIniKey(lines, key, value) {
+    const prefix = `${key}=`;
+    let found = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].startsWith(prefix)) {
+            lines[i] = prefix + value;
+            found = true;
+            break;
+        }
+    }
+    if (!found) {
+        lines.push(prefix + value);
+    }
+}
+exports.updateIniKey = updateIniKey;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/github.d.ts

@@ -0,0 +1,4 @@
+export declare function fetchPreviousVersion(token: string, options?: {
+    priorTo?: string;
+    majorVersion?: string;
+}): Promise<string>;

package/lib/github.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchPreviousVersion = void 0;
+const rest_1 = require("@octokit/rest");
+const semver = require("semver");
+async function fetchPreviousVersion(token, options) {
+    const github = new rest_1.Octokit({ auth: token });
+    const releases = await github.repos.listReleases({
+        owner: 'aws',
+        repo: 'aws-cdk',
+    });
+    // this returns a list in descending order, newest releases first
+    // opts for same major version where possible, falling back otherwise
+    // to previous major versions.
+    let previousMVRelease = undefined;
+    for (const release of releases.data) {
+        const version = release.name?.replace('v', '');
+        if (!version) {
+            continue;
+        }
+        // Any old version is fine
+        if (!options?.majorVersion && !options?.priorTo) {
+            return version;
+        }
+        if (options?.majorVersion && `${semver.major(version)}` === options.majorVersion) {
+            return version;
+        }
+        if (options?.priorTo && semver.lt(version, options?.priorTo) && semver.major(version) === semver.major(options.priorTo)) {
+            return version;
+        }
+        // Otherwise return the most recent version that didn't match any
+        if (!previousMVRelease) {
+            previousMVRelease = version;
+        }
+    }
+    if (previousMVRelease) {
+        return previousMVRelease;
+    }
+    throw new Error(`Unable to find previous version given ${JSON.stringify(options)}`);
+}
+exports.fetchPreviousVersion = fetchPreviousVersion;
+;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+export * from './aws';
+export * from './corking';
+export * from './integ-test';
+export * from './memoize';
+export * from './resource-pool';
+export * from './with-sam';
+export * from './shell';
+export * from './with-aws';
+export * from './with-cdk-app';
+export * from './with-packages';
+export * from './with-temporary-directory';
+export * from './resources';

package/lib/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./aws"), exports);
+__exportStar(require("./corking"), exports);
+__exportStar(require("./integ-test"), exports);
+__exportStar(require("./memoize"), exports);
+__exportStar(require("./resource-pool"), exports);
+__exportStar(require("./with-sam"), exports);
+__exportStar(require("./shell"), exports);
+__exportStar(require("./with-aws"), exports);
+__exportStar(require("./with-cdk-app"), exports);
+__exportStar(require("./with-packages"), exports);
+__exportStar(require("./with-temporary-directory"), exports);
+__exportStar(require("./resources"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSx3Q0FBc0I7QUFDdEIsNENBQTBCO0FBQzFCLCtDQUE2QjtBQUM3Qiw0Q0FBMEI7QUFDMUIsa0RBQWdDO0FBQ2hDLDZDQUEyQjtBQUMzQiwwQ0FBd0I7QUFDeEIsNkNBQTJCO0FBQzNCLGlEQUErQjtBQUMvQixrREFBZ0M7QUFDaEMsNkRBQTJDO0FBQzNDLDhDQUE0QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXdzJztcbmV4cG9ydCAqIGZyb20gJy4vY29ya2luZyc7XG5leHBvcnQgKiBmcm9tICcuL2ludGVnLXRlc3QnO1xuZXhwb3J0ICogZnJvbSAnLi9tZW1vaXplJztcbmV4cG9ydCAqIGZyb20gJy4vcmVzb3VyY2UtcG9vbCc7XG5leHBvcnQgKiBmcm9tICcuL3dpdGgtc2FtJztcbmV4cG9ydCAqIGZyb20gJy4vc2hlbGwnO1xuZXhwb3J0ICogZnJvbSAnLi93aXRoLWF3cyc7XG5leHBvcnQgKiBmcm9tICcuL3dpdGgtY2RrLWFwcCc7XG5leHBvcnQgKiBmcm9tICcuL3dpdGgtcGFja2FnZXMnO1xuZXhwb3J0ICogZnJvbSAnLi93aXRoLXRlbXBvcmFyeS1kaXJlY3RvcnknO1xuZXhwb3J0ICogZnJvbSAnLi9yZXNvdXJjZXMnOyJdfQ==

package/lib/integ-test.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+export interface TestContext {
+    readonly randomString: string;
+    readonly output: NodeJS.WritableStream;
+    log(s: string): void;
+}
+/**
+ * A wrapper for jest's 'test' which takes regression-disabled tests into account and prints a banner
+ */
+export declare function integTest(name: string, callback: (context: TestContext) => Promise<void>, timeoutMillis?: number): void;
+export declare function randomString(): string;

package/lib/integ-test.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomString = exports.integTest = void 0;
+const fs = require("fs");
+const path = require("path");
+const corking_1 = require("./corking");
+const SKIP_TESTS = fs.readFileSync(path.join(__dirname, '..', 'skip-tests.txt'), { encoding: 'utf-8' }).split('\n');
+;
+/**
+ * A wrapper for jest's 'test' which takes regression-disabled tests into account and prints a banner
+ */
+function integTest(name, callback, timeoutMillis) {
+    // Integ tests can run concurrently, and are responsible for blocking
+    // themselves if they cannot.  Because `test.concurrent` executes the test
+    // code immediately, regardles of any `--testNamePattern`, this cannot be the
+    // default: test filtering simply does not work with `test.concurrent`.
+    // Instead, we make it opt-in only for the pipeline where we don't do any
+    // selection, but execute all tests unconditionally.
+    const testKind = process.env.JEST_TEST_CONCURRENT === 'true' ? test.concurrent : test;
+    const runner = shouldSkip(name) ? testKind.skip : testKind;
+    runner(name, async () => {
+        const output = new corking_1.MemoryStream();
+        output.write('================================================================\n');
+        output.write(`${name}\n`);
+        output.write('================================================================\n');
+        try {
+            return await callback({
+                output,
+                randomString: randomString(),
+                log(s) {
+                    output.write(`${s}\n`);
+                },
+            });
+        }
+        catch (e) {
+            output.write(e.message);
+            output.write(e.stack);
+            // Print output only if the test fails. Use 'console.log' so the output is buffered by
+            // jest and prints without a stack trace (if verbose: false).
+            // eslint-disable-next-line no-console
+            console.log(output.buffer().toString());
+            throw e;
+        }
+    }, timeoutMillis);
+}
+exports.integTest = integTest;
+function shouldSkip(testName) {
+    return SKIP_TESTS.includes(testName);
+}
+function randomString() {
+    // Crazy
+    return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');
+}
+exports.randomString = randomString;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lists.d.ts

@@ -0,0 +1 @@
+export declare function chunk<A>(n: number, xs: A[]): A[][];

package/lib/lists.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunk = void 0;
+function chunk(n, xs) {
+    const ret = new Array();
+    for (let i = 0; i < xs.length; i += n) {
+        ret.push(xs.slice(i, i + n));
+    }
+    return ret;
+}
+exports.chunk = chunk;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJsaXN0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxTQUFnQixLQUFLLENBQUksQ0FBUyxFQUFFLEVBQU87SUFDekMsTUFBTSxHQUFHLEdBQUcsSUFBSSxLQUFLLEVBQU8sQ0FBQztJQUU3QixLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLElBQUksQ0FBQyxFQUFFO1FBQ3JDLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUM7S0FDOUI7SUFFRCxPQUFPLEdBQUcsQ0FBQztBQUNiLENBQUM7QUFSRCxzQkFRQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBjaHVuazxBPihuOiBudW1iZXIsIHhzOiBBW10pOiBBW11bXSB7XG4gIGNvbnN0IHJldCA9IG5ldyBBcnJheTxBW10+KCk7XG5cbiAgZm9yIChsZXQgaSA9IDA7IGkgPCB4cy5sZW5ndGg7IGkgKz0gbikge1xuICAgIHJldC5wdXNoKHhzLnNsaWNlKGksIGkgKyBuKSk7XG4gIH1cblxuICByZXR1cm4gcmV0O1xufSJdfQ==

package/lib/memoize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Return a memoized version of an function with 0 arguments.
+ *
+ * Async-safe.
+ */
+export declare function memoize0<A>(fn: () => Promise<A>): () => Promise<A>;