jsii-release 0.2.674 → 0.2.676

package/.gitattributes

@@ -5,13 +5,13 @@
 /.gitattributes linguist-generated
 /.github/pull_request_template.md linguist-generated
 /.github/workflows/auto-approve.yml linguist-generated
+/.github/workflows/auto-merge.yml linguist-generated
 /.github/workflows/build.yml linguist-generated
 /.github/workflows/integ.yml linguist-generated
 /.github/workflows/pull-request-lint.yml linguist-generated
 /.github/workflows/release.yml linguist-generated
 /.github/workflows/upgrade-main.yml linguist-generated
 /.gitignore linguist-generated
-/.mergify.yml linguist-generated
 /.npmignore linguist-generated
 /.npmrc linguist-generated
 /.projen/** linguist-generated

package/.projenrc.ts

@@ -1,26 +1,38 @@
 import { readdirSync } from 'fs';
-import { typescript, github } from 'projen';
+import * as cdklabs from 'cdklabs-projen-project-types';
+import { github } from 'projen';
 
-const project = new typescript.TypeScriptProject({
+const project = new cdklabs.CdklabsTypeScriptProject({
+  private: false,
   projenrcTs: true,
   defaultReleaseBranch: 'main',
   name: 'publib',
   description: 'Release jsii modules to multiple package managers',
   releaseToNpm: true,
   repository: 'https://github.com/cdklabs/publib.git',
-  authorName: 'Amazon Web Services',
-  authorOrganization: true,
   authorUrl: 'https://aws.amazon.com',
   homepage: 'https://github.com/cdklabs/publib',
-  autoApproveOptions: {
-    allowedUsernames: ['cdklabs-automation'],
-    secret: 'GITHUB_TOKEN',
-  },
   devDeps: [
     'ts-node',
     '@aws-sdk/client-sts',
+    '@types/glob',
+    '@types/node@^14.17.0',
+    '@types/yargs@^17',
+    'cdklabs-projen-project-types',
   ],
   autoApproveUpgrades: true,
+  deps: [
+    '@aws-sdk/client-codeartifact',
+    '@aws-sdk/credential-providers',
+    '@aws-sdk/types',
+    'glob@10.0.0', // Can't use a newer version of glob, it adds a CLI that depends on 'jackspeak' which has crazy dependencies
+    'yargs@^17',
+    'p-queue@6', // Last non-ESM version
+  ],
+  workflowNodeVersion: '16.x',
+  minNodeVersion: '16.0.0',
+  enablePRAutoMerge: true,
+  setNodeEngineVersion: false,
 });
 
 // we can't use 9.x because it doesn't work with node 10.
@@ -44,6 +56,10 @@ for (const f of readdirSync('./bin').filter(file => file.startsWith('publib')))
   project.addBins({ [shim]: './bin/jsii-release-shim' });
 }
 
+const integ = project.addTask('integ');
+// This replaces the 'testMatch' in package.json with a different glob
+integ.exec('jest --testMatch "<rootDir>/test/**/*.integ.ts"');
+
 //////////////////////////////////////////////////////////////////////
 
 const test = github.GitHub.of(project)?.addWorkflow('integ');
@@ -133,8 +149,7 @@ test?.addJob('test', {
     },
     {
       name: 'Run integration tests',
-      // Replace the 'testMatch' in package.json
-      run: 'npx jest --testMatch "<rootDir>/test/**/*.integ.ts"',
+      run: 'yarn integ',
     },
   ],
 });

package/README.md

@@ -230,6 +230,33 @@ Repository tags will be in the following format:
 |`GIT_COMMIT_MESSAGE`|Optional|The commit message. Defaults to 'chore(release): $VERSION'.|
 |`DRYRUN`|Optional|Set to "true" for a dry run.|
 
+## Publish to CodeArtifact for testing
+
+This package contains the `publib-ca` CLI tool which is intended to use to publish
+packages to CodeArtifact for testing (in a pipeline, before publishing to the
+actual public package managers).
+
+Use the following commands:
+
+`publib-ca create [--no-gc] [--no-login]` creates a new CodeArtifact repository
+with a random name, with upstreams configured for all supported public package
+managers. By default this command runs the `gc` and `login` subcommands
+automatically.
+
+`publib-ca login --repo NAME [--cmd COMMAND]` logs in to a CodeArtifact repository and prepares some files that configure package managers for use with this CodeArtifact repository. If `--cmd` is given, the command is run in an environment
+where all supported package managers have been configured for the given repository.
+Otherwise, activate these settings in the current bash shell by running
+`source ~/.publib-ca/usage/activate.bash`. This will set some
+environment variables and copy some files into the current directory. (Note: the
+CodeArtifact repository used here does not have to be created using `publib-ca create`. It
+is fine if it already existed beforehand).
+
+`publib-ca gc` collects old repositories created using `publib-ca create`.
+
+`publib-ca publish [--repo NAME] DIRECTORY` publishes all packages in the given
+directory to the given repository. If `--repo` is not given, the most recently
+logged-into repository is used, if the login session is still valid.
+
 ## Roadmap
 
 * [X] GitHub Support: Maven

package/bin/publib-ca

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/bin/publib-ca.js');

package/lib/bin/publib-ca.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;

package/lib/bin/publib-ca.js

@@ -0,0 +1,154 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+/**
+ * Publib CodeArtifact CLI
+ */
+/* eslint-disable no-console */
+const yargs = __importStar(require("yargs"));
+const codeartifact_cli_1 = require("../codeartifact/codeartifact-cli");
+const display_1 = require("../codeartifact/display");
+async function main() {
+    await yargs
+        .usage('$0 <command>')
+        .option('assume-role-arn', {
+        description: 'Role to assume before doing CodeArtifact calls',
+        alias: 'a',
+        requiresArg: true,
+        type: 'string',
+    })
+        .command('create', 'Create a temporary CodeArtifact repository with upstreams', cmd => cmd
+        .option('gc', {
+        description: 'Garbage collect old repositories',
+        type: 'boolean',
+        default: true,
+    })
+        .option('login', {
+        description: 'Automatically log in to the newly created repository',
+        type: 'boolean',
+        default: true,
+    }), async (args) => {
+        const cli = new codeartifact_cli_1.CodeArtifactCli({
+            assumeRoleArn: args['assume-role-arn'],
+        });
+        if (args.gc) {
+            await cli.gc();
+        }
+        const repoName = await cli.create();
+        console.log(repoName);
+        if (args.login) {
+            await cli.login(repoName);
+            cli.usageDir.advertise();
+        }
+    })
+        .command('gc', 'Clean up day-old testing repositories', cmd => cmd, async (args) => {
+        const cli = new codeartifact_cli_1.CodeArtifactCli({
+            assumeRoleArn: args['assume-role-arn'],
+        });
+        await cli.gc();
+    })
+        .command('login', 'Login to a given repository', cmd => cmd
+        .option('repo', {
+        alias: 'r',
+        description: 'Name of the repository to log in to',
+        type: 'string',
+        requiresArg: true,
+    })
+        .option('cmd', {
+        alias: 'c',
+        description: 'Run a command in a shell set up for the target repository',
+        type: 'string',
+        requiresArg: true,
+    }), async (args) => {
+        const cli = new codeartifact_cli_1.CodeArtifactCli({
+            assumeRoleArn: args['assume-role-arn'],
+        });
+        await cli.login(args.repo);
+        if (args.cmd) {
+            await cli.runCommand(args.cmd);
+        }
+        else {
+            cli.usageDir.advertise();
+        }
+    })
+        .command('shell', 'Start a subshell with the repository activated', cmd => cmd
+        .option('repo', {
+        alias: 'r',
+        description: 'Name of the repository to log in to',
+        type: 'string',
+        requiresArg: true,
+        demandOption: false,
+    }), async (args) => {
+        var _a;
+        const cli = new codeartifact_cli_1.CodeArtifactCli({
+            assumeRoleArn: args['assume-role-arn'],
+        });
+        const repo = await cli.login(args.repo);
+        const defaultShell = process.platform === 'win32' ? 'cmd' : 'bash';
+        (0, display_1.header)(`Shell activated for ${repo.repositoryName}`);
+        await cli.runInteractively((_a = process.env.SHELL) !== null && _a !== void 0 ? _a : defaultShell);
+    })
+        .command('publish <DIRECTORY>', 'Publish a given directory', cmd => cmd
+        .positional('DIRECTORY', {
+        descripton: 'Directory distribution',
+        type: 'string',
+        demandOption: true,
+    })
+        .option('repo', {
+        alias: 'r',
+        description: 'Name of the repository to create (default: generate unique name)',
+        type: 'string',
+        requiresArg: true,
+    }), async (args) => {
+        const cli = new codeartifact_cli_1.CodeArtifactCli({
+            assumeRoleArn: args['assume-role-arn'],
+        });
+        await cli.publish(args.DIRECTORY, args.repo);
+    })
+        .command('delete', 'Delete testing repository', cmd => cmd
+        .option('repo', {
+        alias: 'r',
+        description: 'Name of the repository to cleanup (default: most recently logged in to)',
+        type: 'string',
+        requiresArg: true,
+    }), async (args) => {
+        const cli = new codeartifact_cli_1.CodeArtifactCli({
+            assumeRoleArn: args['assume-role-arn'],
+        });
+        await cli.delete(args.repo);
+    })
+        .demandCommand(1, 'You must supply a command')
+        .help()
+        .showHelpOnFail(false)
+        .parse();
+}
+exports.main = main;
+main().catch(e => {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"publib-ca.js","sourceRoot":"","sources":["../../src/bin/publib-ca.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Publib CodeArtifact CLI\n */\n/* eslint-disable no-console */\nimport * as yargs from 'yargs';\nimport { CodeArtifactCli } from '../codeartifact/codeartifact-cli';\nimport { header } from '../codeartifact/display';\n\nexport async function main() {\n  await yargs\n    .usage('$0 <command>')\n    .option('assume-role-arn', {\n      description: 'Role to assume before doing CodeArtifact calls',\n      alias: 'a',\n      requiresArg: true,\n      type: 'string',\n    })\n    .command('create', 'Create a temporary CodeArtifact repository with upstreams', cmd => cmd\n      .option('gc', {\n        description: 'Garbage collect old repositories',\n        type: 'boolean',\n        default: true,\n      })\n      .option('login', {\n        description: 'Automatically log in to the newly created repository',\n        type: 'boolean',\n        default: true,\n      }), async (args) => {\n\n      const cli = new CodeArtifactCli({\n        assumeRoleArn: args['assume-role-arn'],\n      });\n\n      if (args.gc) {\n        await cli.gc();\n      }\n\n      const repoName = await cli.create();\n      console.log(repoName);\n\n      if (args.login) {\n        await cli.login(repoName);\n        cli.usageDir.advertise();\n      }\n    })\n    .command('gc', 'Clean up day-old testing repositories', cmd => cmd, async (args) => {\n      const cli = new CodeArtifactCli({\n        assumeRoleArn: args['assume-role-arn'],\n      });\n      await cli.gc();\n    })\n    .command('login', 'Login to a given repository', cmd => cmd\n      .option('repo', {\n        alias: 'r',\n        description: 'Name of the repository to log in to',\n        type: 'string',\n        requiresArg: true,\n      })\n      .option('cmd', {\n        alias: 'c',\n        description: 'Run a command in a shell set up for the target repository',\n        type: 'string',\n        requiresArg: true,\n      }), async (args) => {\n\n      const cli = new CodeArtifactCli({\n        assumeRoleArn: args['assume-role-arn'],\n      });\n      await cli.login(args.repo);\n\n      if (args.cmd) {\n        await cli.runCommand(args.cmd);\n      } else {\n        cli.usageDir.advertise();\n      }\n    })\n    .command('shell', 'Start a subshell with the repository activated', cmd => cmd\n      .option('repo', {\n        alias: 'r',\n        description: 'Name of the repository to log in to',\n        type: 'string',\n        requiresArg: true,\n        demandOption: false,\n      }), async (args) => {\n      const cli = new CodeArtifactCli({\n        assumeRoleArn: args['assume-role-arn'],\n      });\n      const repo = await cli.login(args.repo);\n\n      const defaultShell = process.platform === 'win32' ? 'cmd' : 'bash';\n\n      header(`Shell activated for ${repo.repositoryName}`);\n      await cli.runInteractively(process.env.SHELL ?? defaultShell);\n    })\n    .command('publish <DIRECTORY>', 'Publish a given directory', cmd => cmd\n      .positional('DIRECTORY', {\n        descripton: 'Directory distribution',\n        type: 'string',\n        demandOption: true,\n      })\n      .option('repo', {\n        alias: 'r',\n        description: 'Name of the repository to create (default: generate unique name)',\n        type: 'string',\n        requiresArg: true,\n      }), async (args) => {\n\n      const cli = new CodeArtifactCli({\n        assumeRoleArn: args['assume-role-arn'],\n      });\n      await cli.publish(args.DIRECTORY, args.repo);\n    })\n    .command('delete', 'Delete testing repository', cmd => cmd\n      .option('repo', {\n        alias: 'r',\n        description: 'Name of the repository to cleanup (default: most recently logged in to)',\n        type: 'string',\n        requiresArg: true,\n      }), async (args) => {\n\n      const cli = new CodeArtifactCli({\n        assumeRoleArn: args['assume-role-arn'],\n      });\n      await cli.delete(args.repo);\n    })\n    .demandCommand(1, 'You must supply a command')\n    .help()\n    .showHelpOnFail(false)\n    .parse();\n}\n\nmain().catch(e => {\n  // eslint-disable-next-line no-console\n  console.error(e);\n  process.exitCode = 1;\n});\n"]}

package/lib/codeartifact/codeartifact-cli.d.ts

@@ -0,0 +1,31 @@
+import { LoginInformation } from './codeartifact-repo';
+import { UsageDir } from './usage-dir';
+export interface CodeArtifactCliOptions {
+    readonly assumeRoleArn?: string;
+}
+export declare class CodeArtifactCli {
+    private readonly options;
+    readonly usageDir: UsageDir;
+    constructor(options?: CodeArtifactCliOptions);
+    private get repoOptions();
+    /**
+     * Create a random repository, return its name
+     */
+    create(): Promise<string>;
+    /**
+     * Delete the given repo
+     */
+    delete(repoName?: string): Promise<void>;
+    /**
+     * Log in to the given repo, write activation instructins to the usage dir
+     */
+    login(repoName?: string): Promise<LoginInformation>;
+    publish(directory: string, repoName?: string): Promise<void>;
+    gc(): Promise<void>;
+    runCommand(command: string): Promise<void>;
+    runInteractively(command: string): Promise<void>;
+    /**
+     * Return a CodeArtifactRepo object, either from the name argument or the most recently activated repository
+     */
+    private repoFromName;
+}

package/lib/codeartifact/codeartifact-cli.js

@@ -0,0 +1,133 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeArtifactCli = void 0;
+const child_process = __importStar(require("child_process"));
+const path = __importStar(require("path"));
+const credential_providers_1 = require("@aws-sdk/credential-providers");
+const glob = __importStar(require("glob"));
+const codeartifact_repo_1 = require("./codeartifact-repo");
+const shell_1 = require("./shell");
+const maven_1 = require("./staging/maven");
+const npm_1 = require("./staging/npm");
+const nuget_1 = require("./staging/nuget");
+const pip_1 = require("./staging/pip");
+const usage_dir_1 = require("./usage-dir");
+const LOGIN_DATA_KEY = 'login';
+class CodeArtifactCli {
+    constructor(options = {}) {
+        this.options = options;
+        this.usageDir = usage_dir_1.UsageDir.default();
+    }
+    get repoOptions() {
+        return {
+            credentials: this.options.assumeRoleArn ? (0, credential_providers_1.fromTemporaryCredentials)({
+                params: {
+                    RoleArn: this.options.assumeRoleArn,
+                    DurationSeconds: 3600,
+                    RoleSessionName: 'publib-ca',
+                },
+            }) : undefined,
+        };
+    }
+    /**
+     * Create a random repository, return its name
+     */
+    async create() {
+        const repo = await codeartifact_repo_1.CodeArtifactRepo.createRandom(this.repoOptions);
+        return repo.repositoryName;
+    }
+    /**
+     * Delete the given repo
+     */
+    async delete(repoName) {
+        const repo = await this.repoFromName(repoName);
+        await repo.delete();
+        if (!repoName) {
+            await this.usageDir.delete();
+        }
+    }
+    /**
+     * Log in to the given repo, write activation instructins to the usage dir
+     */
+    async login(repoName) {
+        const repo = await this.repoFromName(repoName);
+        const login = await repo.login();
+        await this.usageDir.reset();
+        await this.usageDir.putJson(LOGIN_DATA_KEY, login);
+        await this.usageDir.addToEnv({
+            CODEARTIFACT_REPO: login.repositoryName,
+        });
+        await (0, npm_1.npmLogin)(login, this.usageDir);
+        await (0, pip_1.pipLogin)(login, this.usageDir);
+        await (0, maven_1.mavenLogin)(login, this.usageDir);
+        await (0, nuget_1.nugetLogin)(login, this.usageDir);
+        return login;
+    }
+    async publish(directory, repoName) {
+        const repo = await this.repoFromName(repoName);
+        const login = await repo.login();
+        await (0, npm_1.uploadNpmPackages)(glob.sync(path.join(directory, 'js', '*.tgz')), login, this.usageDir);
+        await (0, pip_1.uploadPythonPackages)(glob.sync(path.join(directory, 'python', '*')), login);
+        await (0, maven_1.uploadJavaPackages)(glob.sync(path.join(directory, 'java', '**', '*.pom')), login, this.usageDir);
+        await (0, nuget_1.uploadDotnetPackages)(glob.sync(path.join(directory, 'dotnet', '**', '*.nupkg')), this.usageDir);
+        console.log('🛍 Configuring packages for upstream versions');
+        await repo.markAllUpstreamAllow();
+    }
+    async gc() {
+        await codeartifact_repo_1.CodeArtifactRepo.gc(this.repoOptions);
+    }
+    async runCommand(command) {
+        await this.usageDir.activateInCurrentProcess();
+        await (0, shell_1.shell)(command, {
+            shell: true,
+            show: 'always',
+        });
+    }
+    async runInteractively(command) {
+        await this.usageDir.activateInCurrentProcess();
+        child_process.execSync(command, {
+            env: process.env,
+            stdio: ['inherit', 'inherit', 'inherit'],
+        });
+    }
+    /**
+     * Return a CodeArtifactRepo object, either from the name argument or the most recently activated repository
+     */
+    async repoFromName(repoName) {
+        if (repoName) {
+            return codeartifact_repo_1.CodeArtifactRepo.existing(repoName, this.repoOptions);
+        }
+        const loginInfo = await this.usageDir.readJson(LOGIN_DATA_KEY);
+        if (loginInfo && loginInfo.expirationTimeMs > Date.now()) {
+            const existing = codeartifact_repo_1.CodeArtifactRepo.existing(loginInfo.repositoryName, this.repoOptions);
+            existing.setLoginInformation(loginInfo);
+            return existing;
+        }
+        throw new Error('No repository name given, and no repository activated recently. Login to a repo or pass a repo name.');
+    }
+}
+exports.CodeArtifactCli = CodeArtifactCli;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codeartifact-cli.js","sourceRoot":"","sources":["../../src/codeartifact/codeartifact-cli.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from 'child_process';\nimport * as path from 'path';\nimport { fromTemporaryCredentials } from '@aws-sdk/credential-providers';\nimport * as glob from 'glob';\nimport { CodeArtifactRepo, CodeArtifactRepoOptions, LoginInformation } from './codeartifact-repo';\nimport { shell } from './shell';\nimport { uploadJavaPackages, mavenLogin } from './staging/maven';\nimport { uploadNpmPackages, npmLogin } from './staging/npm';\nimport { uploadDotnetPackages, nugetLogin } from './staging/nuget';\nimport { uploadPythonPackages, pipLogin } from './staging/pip';\nimport { UsageDir } from './usage-dir';\n\nconst LOGIN_DATA_KEY = 'login';\n\nexport interface CodeArtifactCliOptions {\n  readonly assumeRoleArn?: string;\n}\n\nexport class CodeArtifactCli {\n  public readonly usageDir = UsageDir.default();\n\n  constructor(private readonly options: CodeArtifactCliOptions = {}) {\n  }\n\n  private get repoOptions(): CodeArtifactRepoOptions {\n    return {\n      credentials: this.options.assumeRoleArn ? fromTemporaryCredentials({\n        params: {\n          RoleArn: this.options.assumeRoleArn,\n          DurationSeconds: 3600,\n          RoleSessionName: 'publib-ca',\n        },\n      }) : undefined,\n    };\n  }\n\n  /**\n   * Create a random repository, return its name\n   */\n  public async create() {\n    const repo = await CodeArtifactRepo.createRandom(this.repoOptions);\n    return repo.repositoryName;\n  }\n\n  /**\n   * Delete the given repo\n   */\n  public async delete(repoName?: string) {\n    const repo = await this.repoFromName(repoName);\n    await repo.delete();\n\n    if (!repoName) {\n      await this.usageDir.delete();\n    }\n  }\n\n  /**\n   * Log in to the given repo, write activation instructins to the usage dir\n   */\n  public async login(repoName?: string) {\n    const repo = await this.repoFromName(repoName);\n    const login = await repo.login();\n\n    await this.usageDir.reset();\n    await this.usageDir.putJson(LOGIN_DATA_KEY, login);\n\n    await this.usageDir.addToEnv({\n      CODEARTIFACT_REPO: login.repositoryName,\n    });\n\n    await npmLogin(login, this.usageDir);\n    await pipLogin(login, this.usageDir);\n    await mavenLogin(login, this.usageDir);\n    await nugetLogin(login, this.usageDir);\n\n    return login;\n  }\n\n  public async publish(directory: string, repoName?: string) {\n    const repo = await this.repoFromName(repoName);\n    const login = await repo.login();\n\n    await uploadNpmPackages(glob.sync(path.join(directory, 'js', '*.tgz')), login, this.usageDir);\n\n    await uploadPythonPackages(glob.sync(path.join(directory, 'python', '*')), login);\n\n    await uploadJavaPackages(glob.sync(path.join(directory, 'java', '**', '*.pom')), login, this.usageDir);\n\n    await uploadDotnetPackages(glob.sync(path.join(directory, 'dotnet', '**', '*.nupkg')), this.usageDir);\n\n    console.log('🛍 Configuring packages for upstream versions');\n    await repo.markAllUpstreamAllow();\n  }\n\n  public async gc() {\n    await CodeArtifactRepo.gc(this.repoOptions);\n  }\n\n  public async runCommand(command: string) {\n    await this.usageDir.activateInCurrentProcess();\n    await shell(command, {\n      shell: true,\n      show: 'always',\n    });\n  }\n\n  public async runInteractively(command: string) {\n    await this.usageDir.activateInCurrentProcess();\n    child_process.execSync(command, {\n      env: process.env,\n      stdio: ['inherit', 'inherit', 'inherit'],\n    });\n  }\n\n  /**\n   * Return a CodeArtifactRepo object, either from the name argument or the most recently activated repository\n   */\n  private async repoFromName(repoName?: string) {\n    if (repoName) {\n      return CodeArtifactRepo.existing(repoName, this.repoOptions);\n    }\n\n    const loginInfo = await this.usageDir.readJson<LoginInformation>(LOGIN_DATA_KEY) ;\n\n    if (loginInfo && loginInfo.expirationTimeMs > Date.now()) {\n      const existing = CodeArtifactRepo.existing(loginInfo.repositoryName, this.repoOptions);\n      existing.setLoginInformation(loginInfo);\n      return existing;\n    }\n\n    throw new Error('No repository name given, and no repository activated recently. Login to a repo or pass a repo name.');\n  }\n}\n"]}

package/lib/codeartifact/codeartifact-repo.d.ts

@@ -0,0 +1,69 @@
+import { AwsCredentialIdentityProvider } from '@aws-sdk/types';
+export interface CodeArtifactRepoOptions {
+    readonly credentials?: AwsCredentialIdentityProvider;
+}
+/**
+ * A CodeArtifact repository
+ */
+export declare class CodeArtifactRepo {
+    readonly repositoryName: string;
+    static readonly DEFAULT_DOMAIN = "publib-ca";
+    /**
+     * Create a CodeArtifact repo with a random name
+     */
+    static createRandom(options?: CodeArtifactRepoOptions): Promise<CodeArtifactRepo>;
+    /**
+     * Create a CodeArtifact repository with a given name
+     */
+    static createWithName(name: string, options?: CodeArtifactRepoOptions): Promise<CodeArtifactRepo>;
+    /**
+     * Reference an existing CodeArtifact repository
+     */
+    static existing(repositoryName: string, options?: CodeArtifactRepoOptions): CodeArtifactRepo;
+    /**
+     * Garbage collect repositories
+     */
+    static gc(options?: CodeArtifactRepoOptions): Promise<void>;
+    readonly npmUpstream = "npm-upstream";
+    readonly pypiUpstream = "pypi-upstream";
+    readonly nugetUpstream = "nuget-upstream";
+    readonly mavenUpstream = "maven-upstream";
+    readonly domain = "publib-ca";
+    private readonly codeArtifact;
+    private _loginInformation;
+    private constructor();
+    /**
+     * Create the repository
+     */
+    create(): Promise<void>;
+    /**
+     * Absorb old login information
+     */
+    setLoginInformation(loginInfo: LoginInformation): void;
+    login(): 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;
+    private send;
+}
+export interface LoginInformation {
+    readonly authToken: string;
+    readonly expirationTimeMs: number;
+    readonly repositoryName: string;
+    readonly npmEndpoint: string;
+    readonly mavenEndpoint: string;
+    readonly nugetEndpoint: string;
+    readonly pypiEndpoint: string;
+}