@aws-cdk-testing/cli-integ 0.0.0

package/lib/shell.ts

@@ -0,0 +1,168 @@
+import * as child_process from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { TestContext } from './integ-test';
+import { TemporaryDirectoryContext } from './with-temporary-directory';
+
+/**
+ * A shell command that does what you want
+ *
+ * Is platform-aware, handles errors nicely.
+ */
+export async function shell(command: string[], options: ShellOptions = {}): Promise<string> {
+  if (options.modEnv && options.env) {
+    throw new Error('Use either env or modEnv but not both');
+  }
+
+  const outputs = new Set(options.outputs);
+  const writeToOutputs = (x: string) => {
+    for (const outputStream of outputs) {
+      outputStream.write(x);
+    }
+  };
+
+  // Always output the command
+  writeToOutputs(`💻 ${command.join(' ')}\n`);
+  const show = options.show ?? 'always';
+
+  if (process.env.VERBOSE) {
+    outputs.add(process.stdout);
+  }
+
+  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : process.env);
+
+  const child = child_process.spawn(command[0], command.slice(1), {
+    ...options,
+    env,
+    // Need this for Windows where we want .cmd and .bat to be found as well.
+    shell: true,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  return new Promise<string>((resolve, reject) => {
+    const stdout = new Array<Buffer>();
+    const stderr = new Array<Buffer>();
+
+    child.stdout!.on('data', chunk => {
+      if (show === 'always') {
+        writeToOutputs(chunk);
+      }
+      stdout.push(chunk);
+    });
+
+    child.stderr!.on('data', chunk => {
+      if (show === 'always') {
+        writeToOutputs(chunk);
+      }
+      if (options.captureStderr ?? true) {
+        stderr.push(chunk);
+      }
+    });
+
+    child.once('error', reject);
+
+    child.once('close', code => {
+      const stderrOutput = Buffer.concat(stderr).toString('utf-8');
+      const stdoutOutput = Buffer.concat(stdout).toString('utf-8');
+      const out = (options.onlyStderr ? stderrOutput : stdoutOutput + stderrOutput).trim();
+      if (code === 0 || options.allowErrExit) {
+        resolve(out);
+      } else {
+        if (show === 'error') {
+          writeToOutputs(`${out}\n`);
+        }
+        reject(new Error(`'${command.join(' ')}' exited with error code ${code}.`));
+      }
+    });
+  });
+}
+
+export interface ShellOptions extends child_process.SpawnOptions {
+  /**
+   * Properties to add to 'env'
+   */
+  readonly modEnv?: Record<string, string>;
+
+  /**
+   * Don't fail when exiting with an error
+   *
+   * @default false
+   */
+  readonly allowErrExit?: boolean;
+
+  /**
+   * Whether to capture stderr
+   *
+   * @default true
+   */
+  readonly captureStderr?: boolean;
+
+  /**
+   * Pass output here
+   */
+  readonly outputs?: NodeJS.WritableStream[];
+
+  /**
+   * Only return stderr. For example, this is used to validate
+   * that when CI=true, all logs are sent to stdout.
+   *
+   * @default false
+   */
+  readonly onlyStderr?: boolean;
+
+  /**
+   * Don't log to stdout
+   *
+   * @default always
+   */
+  readonly show?: 'always' | 'never' | 'error';
+}
+
+export class ShellHelper {
+  public static fromContext(context: TestContext & TemporaryDirectoryContext) {
+    return new ShellHelper(context.integTestDir, context.output);
+  }
+
+  constructor(
+    private readonly _cwd: string,
+    private readonly _output: NodeJS.WritableStream) { }
+
+  public async shell(command: string[], options: Omit<ShellOptions, 'cwd' | 'outputs'> = {}): Promise<string> {
+    return shell(command, {
+      outputs: [this._output],
+      cwd: this._cwd,
+      ...options,
+    });
+  }
+}
+
+/**
+ * rm -rf reimplementation, don't want to depend on an NPM package for this
+ */
+export function rimraf(fsPath: string) {
+  try {
+    const isDir = fs.lstatSync(fsPath).isDirectory();
+
+    if (isDir) {
+      for (const file of fs.readdirSync(fsPath)) {
+        rimraf(path.join(fsPath, file));
+      }
+      fs.rmdirSync(fsPath);
+    } else {
+      fs.unlinkSync(fsPath);
+    }
+  } catch (e: any) {
+    // We will survive ENOENT
+    if (e.code !== 'ENOENT') { throw e; }
+  }
+}
+
+export function addToShellPath(x: string) {
+  const parts = process.env.PATH?.split(':') ?? [];
+
+  if (!parts.includes(x)) {
+    parts.unshift(x);
+  }
+
+  process.env.PATH = parts.join(':');
+}

package/lib/staging/codeartifact.d.ts

@@ -0,0 +1,44 @@
+export declare class TestRepository {
+    readonly repositoryName: string;
+    static readonly DEFAULT_DOMAIN = "test-cdk";
+    static newRandom(): Promise<TestRepository>;
+    static newWithName(name: string): Promise<TestRepository>;
+    static existing(repositoryName: string): TestRepository;
+    /**
+     * Garbage collect repositories
+     */
+    static gc(): Promise<void>;
+    readonly npmUpstream = "npm-upstream";
+    readonly pypiUpstream = "pypi-upstream";
+    readonly nugetUpstream = "nuget-upstream";
+    readonly mavenUpstream = "maven-upstream";
+    readonly domain = "test-cdk";
+    private readonly codeArtifact;
+    private _loginInformation;
+    private constructor();
+    prepare(): Promise<void>;
+    loginInformation(): Promise<LoginInformation>;
+    delete(): Promise<void>;
+    /**
+     * List all packages and mark them as "allow upstream versions".
+     *
+     * If we don't do this and we publish `foo@2.3.4-rc.0`, then we can't
+     * download `foo@2.3.0` anymore because by default CodeArtifact will
+     * block different versions from the same package.
+     */
+    markAllUpstreamAllow(): Promise<void>;
+    private ensureDomain;
+    private ensureUpstreams;
+    private ensureRepository;
+    private domainExists;
+    private repositoryExists;
+    private listPackages;
+}
+export interface LoginInformation {
+    readonly authToken: string;
+    readonly repositoryName: string;
+    readonly npmEndpoint: string;
+    readonly mavenEndpoint: string;
+    readonly nugetEndpoint: string;
+    readonly pypiEndpoint: string;
+}

package/lib/staging/codeartifact.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestRepository = void 0;
+const client_codeartifact_1 = require("@aws-sdk/client-codeartifact");
+const aws_1 = require("../aws");
+const COLLECT_BY_TAG = 'collect-by';
+const REPO_LIFETIME_MS = 24 * 3600 * 1000; // One day
+class TestRepository {
+    static async newRandom() {
+        const qualifier = Math.random()
+            .toString(36)
+            .replace(/[^a-z0-9]+/g, '');
+        const repo = new TestRepository(`test-${qualifier}`);
+        await repo.prepare();
+        return repo;
+    }
+    static async newWithName(name) {
+        const repo = new TestRepository(name);
+        await repo.prepare();
+        return repo;
+    }
+    static existing(repositoryName) {
+        return new TestRepository(repositoryName);
+    }
+    /**
+     * Garbage collect repositories
+     */
+    static async gc() {
+        var _a, _b;
+        if (!(await TestRepository.existing('*dummy*').domainExists())) {
+            return;
+        }
+        const codeArtifact = new client_codeartifact_1.CodeartifactClient();
+        let nextToken;
+        do {
+            const page = await codeArtifact.send(new client_codeartifact_1.ListRepositoriesCommand({
+                nextToken: nextToken,
+            }));
+            for (const repo of (_a = page.repositories) !== null && _a !== void 0 ? _a : []) {
+                const tags = await codeArtifact.send(new client_codeartifact_1.ListTagsForResourceCommand({
+                    resourceArn: repo.arn,
+                }));
+                const collectable = (_b = tags === null || tags === void 0 ? void 0 : tags.tags) === null || _b === void 0 ? void 0 : _b.find((t) => t.key === COLLECT_BY_TAG && Number(t.value) < Date.now());
+                if (collectable) {
+                    // eslint-disable-next-line no-console
+                    console.log('Deleting', repo.name);
+                    await codeArtifact.send(new client_codeartifact_1.DeleteRepositoryCommand({
+                        domain: repo.domainName,
+                        repository: repo.name,
+                    }));
+                }
+            }
+            nextToken = page.nextToken;
+        } while (nextToken);
+    }
+    constructor(repositoryName) {
+        this.repositoryName = repositoryName;
+        this.npmUpstream = 'npm-upstream';
+        this.pypiUpstream = 'pypi-upstream';
+        this.nugetUpstream = 'nuget-upstream';
+        this.mavenUpstream = 'maven-upstream';
+        this.domain = TestRepository.DEFAULT_DOMAIN;
+        this.codeArtifact = new client_codeartifact_1.CodeartifactClient();
+    }
+    async prepare() {
+        await this.ensureDomain();
+        await this.ensureUpstreams();
+        await this.ensureRepository(this.repositoryName, {
+            description: 'Testing repository',
+            upstreams: [this.npmUpstream, this.pypiUpstream, this.nugetUpstream, this.mavenUpstream],
+            tags: {
+                [COLLECT_BY_TAG]: `${Date.now() + REPO_LIFETIME_MS}`,
+            },
+        });
+    }
+    async loginInformation() {
+        if (this._loginInformation) {
+            return this._loginInformation;
+        }
+        this._loginInformation = {
+            authToken: (await this.codeArtifact.send(new client_codeartifact_1.GetAuthorizationTokenCommand({
+                domain: this.domain,
+                durationSeconds: 12 * 3600,
+            }))).authorizationToken,
+            repositoryName: this.repositoryName,
+            npmEndpoint: (await this.codeArtifact.send(new client_codeartifact_1.GetRepositoryEndpointCommand({
+                domain: this.domain,
+                repository: this.repositoryName,
+                format: 'npm',
+            }))).repositoryEndpoint,
+            mavenEndpoint: (await this.codeArtifact.send(new client_codeartifact_1.GetRepositoryEndpointCommand({
+                domain: this.domain,
+                repository: this.repositoryName,
+                format: 'maven',
+            }))).repositoryEndpoint,
+            nugetEndpoint: (await this.codeArtifact.send(new client_codeartifact_1.GetRepositoryEndpointCommand({
+                domain: this.domain,
+                repository: this.repositoryName,
+                format: 'nuget',
+            }))).repositoryEndpoint,
+            pypiEndpoint: (await this.codeArtifact.send(new client_codeartifact_1.GetRepositoryEndpointCommand({
+                domain: this.domain,
+                repository: this.repositoryName,
+                format: 'pypi',
+            }))).repositoryEndpoint,
+        };
+        return this._loginInformation;
+    }
+    async delete() {
+        try {
+            await this.codeArtifact.send(new client_codeartifact_1.DeleteRepositoryCommand({
+                domain: this.domain,
+                repository: this.repositoryName,
+            }));
+            // eslint-disable-next-line no-console
+            console.log('Deleted', this.repositoryName);
+        }
+        catch (e) {
+            if (e.name !== 'ResourceNotFoundException') {
+                throw e;
+            }
+            // Okay
+        }
+    }
+    /**
+     * List all packages and mark them as "allow upstream versions".
+     *
+     * If we don't do this and we publish `foo@2.3.4-rc.0`, then we can't
+     * download `foo@2.3.0` anymore because by default CodeArtifact will
+     * block different versions from the same package.
+     */
+    async markAllUpstreamAllow() {
+        for await (const pkg of this.listPackages({ upstream: 'BLOCK' })) {
+            await retryThrottled(() => this.codeArtifact.send(new client_codeartifact_1.PutPackageOriginConfigurationCommand({
+                domain: this.domain,
+                repository: this.repositoryName,
+                format: pkg.format,
+                package: pkg.package,
+                namespace: pkg.namespace,
+                restrictions: {
+                    publish: 'ALLOW',
+                    upstream: 'ALLOW',
+                },
+            })));
+        }
+    }
+    async ensureDomain() {
+        if (await this.domainExists()) {
+            return;
+        }
+        await this.codeArtifact.send(new client_codeartifact_1.CreateDomainCommand({
+            domain: this.domain,
+            tags: [{ key: 'testing', value: 'true' }],
+        }));
+    }
+    async ensureUpstreams() {
+        await this.ensureRepository(this.npmUpstream, {
+            description: 'The upstream repository for NPM',
+            external: 'public:npmjs',
+        });
+        await this.ensureRepository(this.mavenUpstream, {
+            description: 'The upstream repository for Maven',
+            external: 'public:maven-central',
+        });
+        await this.ensureRepository(this.nugetUpstream, {
+            description: 'The upstream repository for NuGet',
+            external: 'public:nuget-org',
+        });
+        await this.ensureRepository(this.pypiUpstream, {
+            description: 'The upstream repository for PyPI',
+            external: 'public:pypi',
+        });
+    }
+    async ensureRepository(name, options) {
+        var _a;
+        if (await this.repositoryExists(name)) {
+            return;
+        }
+        await this.codeArtifact.send(new client_codeartifact_1.CreateRepositoryCommand({
+            domain: this.domain,
+            repository: name,
+            description: options === null || options === void 0 ? void 0 : options.description,
+            upstreams: (_a = options === null || options === void 0 ? void 0 : options.upstreams) === null || _a === void 0 ? void 0 : _a.map((repositoryName) => ({ repositoryName })),
+            tags: (options === null || options === void 0 ? void 0 : options.tags) ? Object.entries(options.tags).map(([key, value]) => ({ key, value })) : undefined,
+        }));
+        if (options === null || options === void 0 ? void 0 : options.external) {
+            const externalConnection = options.external;
+            await retry(() => this.codeArtifact.send(new client_codeartifact_1.AssociateExternalConnectionCommand({
+                domain: this.domain,
+                repository: name,
+                externalConnection,
+            })));
+        }
+    }
+    async domainExists() {
+        try {
+            await this.codeArtifact.send(new client_codeartifact_1.DescribeDomainCommand({ domain: this.domain }));
+            return true;
+        }
+        catch (e) {
+            if (e.name !== 'ResourceNotFoundException') {
+                throw e;
+            }
+            return false;
+        }
+    }
+    async repositoryExists(name) {
+        try {
+            await this.codeArtifact.send(new client_codeartifact_1.DescribeRepositoryCommand({ domain: this.domain, repository: name }));
+            return true;
+        }
+        catch (e) {
+            if (e.name !== 'ResourceNotFoundException') {
+                throw e;
+            }
+            return false;
+        }
+    }
+    async *listPackages(filter = {}) {
+        var _a;
+        let response = await retryThrottled(() => this.codeArtifact.send(new client_codeartifact_1.ListPackagesCommand({
+            domain: this.domain,
+            repository: this.repositoryName,
+            ...filter,
+        })));
+        while (true) {
+            for (const p of (_a = response.packages) !== null && _a !== void 0 ? _a : []) {
+                yield p;
+            }
+            if (!response.nextToken) {
+                break;
+            }
+            response = await retryThrottled(() => this.codeArtifact.send(new client_codeartifact_1.ListPackagesCommand({
+                domain: this.domain,
+                repository: this.repositoryName,
+                ...filter,
+                nextToken: response.nextToken,
+            })));
+        }
+    }
+}
+exports.TestRepository = TestRepository;
+TestRepository.DEFAULT_DOMAIN = 'test-cdk';
+async function retry(block) {
+    let attempts = 3;
+    while (true) {
+        try {
+            return await block();
+        }
+        catch (e) {
+            if (attempts-- === 0) {
+                throw e;
+            }
+            // eslint-disable-next-line no-console
+            console.debug(e.message);
+            await (0, aws_1.sleep)(500);
+        }
+    }
+}
+async function retryThrottled(block) {
+    let time = 100;
+    let attempts = 15;
+    while (true) {
+        try {
+            return await block();
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.debug(e.message);
+            if (e.name !== 'ThrottlingException') {
+                throw e;
+            }
+            if (attempts-- === 0) {
+                throw e;
+            }
+            await (0, aws_1.sleep)(Math.floor(Math.random() * time));
+            time *= 2;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codeartifact.js","sourceRoot":"","sources":["codeartifact.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AssociateExternalConnectionCommand,\n  CodeartifactClient,\n  CreateDomainCommand,\n  CreateRepositoryCommand,\n  DeleteRepositoryCommand,\n  DescribeDomainCommand,\n  DescribeRepositoryCommand,\n  GetAuthorizationTokenCommand,\n  GetRepositoryEndpointCommand,\n  ListPackagesCommand,\n  ListPackagesRequest,\n  ListRepositoriesCommand,\n  ListTagsForResourceCommand,\n  PutPackageOriginConfigurationCommand,\n} from '@aws-sdk/client-codeartifact';\nimport { sleep } from '../aws';\n\nconst COLLECT_BY_TAG = 'collect-by';\nconst REPO_LIFETIME_MS = 24 * 3600 * 1000; // One day\n\nexport class TestRepository {\n  public static readonly DEFAULT_DOMAIN = 'test-cdk';\n\n  public static async newRandom() {\n    const qualifier = Math.random()\n      .toString(36)\n      .replace(/[^a-z0-9]+/g, '');\n\n    const repo = new TestRepository(`test-${qualifier}`);\n    await repo.prepare();\n    return repo;\n  }\n\n  public static async newWithName(name: string) {\n    const repo = new TestRepository(name);\n    await repo.prepare();\n    return repo;\n  }\n\n  public static existing(repositoryName: string) {\n    return new TestRepository(repositoryName);\n  }\n\n  /**\n   * Garbage collect repositories\n   */\n  public static async gc() {\n    if (!(await TestRepository.existing('*dummy*').domainExists())) {\n      return;\n    }\n\n    const codeArtifact = new CodeartifactClient();\n\n    let nextToken: string | undefined;\n    do {\n      const page = await codeArtifact.send(\n        new ListRepositoriesCommand({\n          nextToken: nextToken,\n        }),\n      );\n\n      for (const repo of page.repositories ?? []) {\n        const tags = await codeArtifact.send(\n          new ListTagsForResourceCommand({\n            resourceArn: repo.arn!,\n          }),\n        );\n        const collectable = tags?.tags?.find((t) => t.key === COLLECT_BY_TAG && Number(t.value) < Date.now());\n        if (collectable) {\n          // eslint-disable-next-line no-console\n          console.log('Deleting', repo.name);\n          await codeArtifact.send(\n            new DeleteRepositoryCommand({\n              domain: repo.domainName!,\n              repository: repo.name!,\n            }),\n          );\n        }\n      }\n\n      nextToken = page.nextToken;\n    } while (nextToken);\n  }\n\n  public readonly npmUpstream = 'npm-upstream';\n  public readonly pypiUpstream = 'pypi-upstream';\n  public readonly nugetUpstream = 'nuget-upstream';\n  public readonly mavenUpstream = 'maven-upstream';\n  public readonly domain = TestRepository.DEFAULT_DOMAIN;\n\n  private readonly codeArtifact = new CodeartifactClient();\n\n  private _loginInformation: LoginInformation | undefined;\n\n  private constructor(public readonly repositoryName: string) {}\n\n  public async prepare() {\n    await this.ensureDomain();\n    await this.ensureUpstreams();\n\n    await this.ensureRepository(this.repositoryName, {\n      description: 'Testing repository',\n      upstreams: [this.npmUpstream, this.pypiUpstream, this.nugetUpstream, this.mavenUpstream],\n      tags: {\n        [COLLECT_BY_TAG]: `${Date.now() + REPO_LIFETIME_MS}`,\n      },\n    });\n  }\n\n  public async loginInformation(): Promise<LoginInformation> {\n    if (this._loginInformation) {\n      return this._loginInformation;\n    }\n\n    this._loginInformation = {\n      authToken: (\n        await this.codeArtifact.send(\n          new GetAuthorizationTokenCommand({\n            domain: this.domain,\n            durationSeconds: 12 * 3600,\n          }),\n        )\n      ).authorizationToken!,\n      repositoryName: this.repositoryName,\n\n      npmEndpoint: (\n        await this.codeArtifact.send(\n          new GetRepositoryEndpointCommand({\n            domain: this.domain,\n            repository: this.repositoryName,\n            format: 'npm',\n          }),\n        )\n      ).repositoryEndpoint!,\n\n      mavenEndpoint: (\n        await this.codeArtifact.send(\n          new GetRepositoryEndpointCommand({\n            domain: this.domain,\n            repository: this.repositoryName,\n            format: 'maven',\n          }),\n        )\n      ).repositoryEndpoint!,\n\n      nugetEndpoint: (\n        await this.codeArtifact.send(\n          new GetRepositoryEndpointCommand({\n            domain: this.domain,\n            repository: this.repositoryName,\n            format: 'nuget',\n          }),\n        )\n      ).repositoryEndpoint!,\n\n      pypiEndpoint: (\n        await this.codeArtifact.send(\n          new GetRepositoryEndpointCommand({\n            domain: this.domain,\n            repository: this.repositoryName,\n            format: 'pypi',\n          }),\n        )\n      ).repositoryEndpoint!,\n    };\n    return this._loginInformation;\n  }\n\n  public async delete() {\n    try {\n      await this.codeArtifact.send(\n        new DeleteRepositoryCommand({\n          domain: this.domain,\n          repository: this.repositoryName,\n        }),\n      );\n\n      // eslint-disable-next-line no-console\n      console.log('Deleted', this.repositoryName);\n    } catch (e: any) {\n      if (e.name !== 'ResourceNotFoundException') {\n        throw e;\n      }\n      // Okay\n    }\n  }\n\n  /**\n   * List all packages and mark them as \"allow upstream versions\".\n   *\n   * If we don't do this and we publish `foo@2.3.4-rc.0`, then we can't\n   * download `foo@2.3.0` anymore because by default CodeArtifact will\n   * block different versions from the same package.\n   */\n  public async markAllUpstreamAllow() {\n    for await (const pkg of this.listPackages({ upstream: 'BLOCK' })) {\n      await retryThrottled(() =>\n        this.codeArtifact.send(\n          new PutPackageOriginConfigurationCommand({\n            domain: this.domain,\n            repository: this.repositoryName,\n\n            format: pkg.format!,\n            package: pkg.package!,\n            namespace: pkg.namespace!,\n            restrictions: {\n              publish: 'ALLOW',\n              upstream: 'ALLOW',\n            },\n          }),\n        ),\n      );\n    }\n  }\n\n  private async ensureDomain() {\n    if (await this.domainExists()) {\n      return;\n    }\n    await this.codeArtifact.send(\n      new CreateDomainCommand({\n        domain: this.domain,\n        tags: [{ key: 'testing', value: 'true' }],\n      }),\n    );\n  }\n\n  private async ensureUpstreams() {\n    await this.ensureRepository(this.npmUpstream, {\n      description: 'The upstream repository for NPM',\n      external: 'public:npmjs',\n    });\n    await this.ensureRepository(this.mavenUpstream, {\n      description: 'The upstream repository for Maven',\n      external: 'public:maven-central',\n    });\n    await this.ensureRepository(this.nugetUpstream, {\n      description: 'The upstream repository for NuGet',\n      external: 'public:nuget-org',\n    });\n    await this.ensureRepository(this.pypiUpstream, {\n      description: 'The upstream repository for PyPI',\n      external: 'public:pypi',\n    });\n  }\n\n  private async ensureRepository(\n    name: string,\n    options?: {\n      readonly description?: string;\n      readonly external?: string;\n      readonly upstreams?: string[];\n      readonly tags?: Record<string, string>;\n    },\n  ) {\n    if (await this.repositoryExists(name)) {\n      return;\n    }\n\n    await this.codeArtifact.send(\n      new CreateRepositoryCommand({\n        domain: this.domain,\n        repository: name,\n        description: options?.description,\n        upstreams: options?.upstreams?.map((repositoryName) => ({ repositoryName })),\n        tags: options?.tags ? Object.entries(options.tags).map(([key, value]) => ({ key, value })) : undefined,\n      }),\n    );\n\n    if (options?.external) {\n      const externalConnection = options.external;\n      await retry(() =>\n        this.codeArtifact.send(\n          new AssociateExternalConnectionCommand({\n            domain: this.domain,\n            repository: name,\n            externalConnection,\n          }),\n        ),\n      );\n    }\n  }\n\n  private async domainExists() {\n    try {\n      await this.codeArtifact.send(new DescribeDomainCommand({ domain: this.domain }));\n      return true;\n    } catch (e: any) {\n      if (e.name !== 'ResourceNotFoundException') {\n        throw e;\n      }\n      return false;\n    }\n  }\n\n  private async repositoryExists(name: string) {\n    try {\n      await this.codeArtifact.send(new DescribeRepositoryCommand({ domain: this.domain, repository: name }));\n      return true;\n    } catch (e: any) {\n      if (e.name !== 'ResourceNotFoundException') {\n        throw e;\n      }\n      return false;\n    }\n  }\n\n  private async *listPackages(filter: Pick<ListPackagesRequest, 'upstream' | 'publish' | 'format'> = {}) {\n    let response = await retryThrottled(() =>\n      this.codeArtifact.send(\n        new ListPackagesCommand({\n          domain: this.domain,\n          repository: this.repositoryName,\n          ...filter,\n        }),\n      ),\n    );\n\n    while (true) {\n      for (const p of response.packages ?? []) {\n        yield p;\n      }\n\n      if (!response.nextToken) {\n        break;\n      }\n\n      response = await retryThrottled(() =>\n        this.codeArtifact.send(\n          new ListPackagesCommand({\n            domain: this.domain,\n            repository: this.repositoryName,\n            ...filter,\n            nextToken: response.nextToken,\n          }),\n        ),\n      );\n    }\n  }\n}\n\nasync function retry<A>(block: () => Promise<A>) {\n  let attempts = 3;\n  while (true) {\n    try {\n      return await block();\n    } catch (e: any) {\n      if (attempts-- === 0) {\n        throw e;\n      }\n      // eslint-disable-next-line no-console\n      console.debug(e.message);\n      await sleep(500);\n    }\n  }\n}\n\nasync function retryThrottled<A>(block: () => Promise<A>) {\n  let time = 100;\n  let attempts = 15;\n  while (true) {\n    try {\n      return await block();\n    } catch (e: any) {\n      // eslint-disable-next-line no-console\n      console.debug(e.message);\n      if (e.name !== 'ThrottlingException') {\n        throw e;\n      }\n      if (attempts-- === 0) {\n        throw e;\n      }\n      await sleep(Math.floor(Math.random() * time));\n      time *= 2;\n    }\n  }\n}\n\nexport interface LoginInformation {\n  readonly authToken: string;\n  readonly repositoryName: string;\n  readonly npmEndpoint: string;\n  readonly mavenEndpoint: string;\n  readonly nugetEndpoint: string;\n  readonly pypiEndpoint: string;\n}\n"]}