jsii-diff 1.35.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,2 @@
+jsii
+Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.

package/README.md

@@ -0,0 +1,111 @@
+# jsii-diff
+
+__jsii-diff__ compares two jsii assemblies for compatibility.
+
+In the future, it will be able to do generic comparisons, but for
+now it will compare assemblies for API compatibility, and exit
+with a non-zero exit code if any **stable** APIs have had incompatible
+changes.
+
+API items that have no stability are treated as **stable**. To treat
+unmarked API items as experimental, pass the `--default-experimental` flag.
+
+## Usage
+
+To compare two JSII packages:
+
+    jsii-diff <old> [new]
+
+Packages can be identified by either:
+
+* **A path**, in which case it should be the path to a JSII package directory,
+  or to a `.jsii` file.
+* **An NPM package specifier** of the form `npm:[<package>[@version]]`, in
+  which case the indicated version is downloaded and used. If `@version` is
+  left out, the latest version will be used. If `package` is left out,
+  the assembly name of `.jsii` in the current directory will be used.
+
+To compare current package against latest published NPM release:
+
+    jsii-diff npm:
+
+## Details
+
+__jsii-diff__ will assert that code written against version **A** of a library
+will still typecheck when compiled against version **B** of that library. It
+does this by verifying the following properties:
+
+- Any type (class/interface/enum) in **A** must also exist in **B**.
+- Enums have only added members.
+- Classes and interfaces have only added members, or modified existing
+  members in an allowed way.
+- Property types are the same or have been strengthened (see below).
+- Methods have only added optional arguments, existing argument types have
+  only been weakened, and the return type has only been strengthened (see below).
+
+### Strengthening and weakening
+
+- *Strengthening* a type refers to *excluding* more possible values. Changing
+  a field from `optional` to `required`, or changing a type from `any` to
+  `string` are examples of strengthening.
+
+- As the opposite of strengthening, *weakening* refers to *allowing* more
+  possible values. Changing a field from `required` to `optional`, or
+  changing a type to a superclass or interface are examples of weakening.
+
+An API can change in the following way without breaking its consumer:
+
+- It can *weaken* its input (require *less* from the caller); and
+- It can *strengthen* its output (guarantee *more* to the caller).
+
+### Struct types
+
+Structs (interfaces consisting completely of `readonly` properties) are
+treated as bags of data. Their API compatibility will be evaluated depending
+on whether they appear in input or output position of operations.
+
+- Structs are *weakened* if all types of all of its properties are weakened.
+  Normally removing properties would also be considered weakening, but
+  because that may cause references to the fields in existing code bases to
+  become undefined (which is not allowed in most programming languages) we
+  disallow removing properties.
+- Structs are *strengthened* if all types of all of its properties are
+  strengthened, or if fields are added.
+
+__jsii-diff__ will check the evolution of structs against their position
+in an operation, similar to other types. Input structs may be weakened,
+and output structs may be strengthened.
+
+### Reference types
+
+Classes and non-struct interface types are considered "reference types". By
+default we treat them as being the result of a function call:
+
+* Class instances are the return values calling their constructors.
+* Interfaces are only ever implemented by objects returned from the framework,
+  or returned by factory functions.
+
+This means their evolution falls under the rules of "strengthening": they
+may only add fields, never take any away or make them optional.
+
+#### `@subclassable`
+
+Some classes or interfaces may be intended to be implemented by consumers.
+Those should be marked with the docstring tag `@subclassable`.
+
+This will effectively cause changes against those types to be checked against
+the rules for weakening as well (i.e., no new (abstract) fields or members
+added). This is necessary because otherwise any existing implementor of that
+interface would be broken, since they wouldn't be implementing the new
+abstract members yet.
+
+`@subclassable` is not the default since most interfaces are not intended
+for subclassing, but treating them as such would limit the evolvability of
+libraries too much.
+
+## License
+
+__jsii-diff__ is distributed under the
+[Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).
+
+See [LICENSE](./LICENSE) and [NOTICE](./NOTICE) for more information.

package/bin/jsii-diff

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

package/bin/jsii-diff.d.ts

@@ -0,0 +1 @@
+import '@jsii/check-node/run';

package/bin/jsii-diff.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@jsii/check-node/run");
+const spec = require("@jsii/spec");
+const fs = require("fs-extra");
+const reflect = require("jsii-reflect");
+const log4js = require("log4js");
+const yargs = require("yargs");
+const lib_1 = require("../lib");
+const diagnostics_1 = require("../lib/diagnostics");
+const util_1 = require("../lib/util");
+const version_1 = require("../lib/version");
+const LOG = log4js.getLogger('jsii-diff');
+async function main() {
+    const argv = yargs
+        .env('JSII_DIFF')
+        .option('verbose', {
+        alias: 'v',
+        type: 'count',
+        desc: 'Increase the verbosity of output',
+        global: true,
+    })
+        .option('default-stability', {
+        alias: 's',
+        type: 'string',
+        choices: ['experimental', 'stable'],
+        desc: 'Treat unmarked APIs as',
+        default: 'stable',
+    })
+        .option('experimental-errors', {
+        alias: 'e',
+        type: 'boolean',
+        default: false,
+        desc: 'Error on experimental API changes',
+    })
+        .option('ignore-file', {
+        alias: 'i',
+        type: 'string',
+        desc: 'Ignore API changes with keys from file (file may be missing)',
+    })
+        .option('keys', {
+        alias: 'k',
+        type: 'boolean',
+        default: false,
+        desc: 'Show diagnostic suppression keys',
+    })
+        .option('validate', {
+        alias: 'd',
+        type: 'boolean',
+        default: false,
+        desc: 'Validate the assemblies that are being loaded',
+    })
+        .usage('$0 <original> [updated]', 'Compare two JSII assemblies.', (args) => args
+        .positional('original', {
+        description: 'Original assembly (file, package or "npm:package@version")',
+        type: 'string',
+    })
+        .positional('updated', {
+        description: 'New assembly (file, package or "npm:package@version")',
+        type: 'string',
+        default: '.',
+    }))
+        .help()
+        .version(version_1.VERSION).argv;
+    configureLog4js(argv.verbose);
+    LOG.debug(`Loading original assembly from ${argv.original}`);
+    const loadOriginal = await loadAssembly(argv.original, argv);
+    if (!loadOriginal.success) {
+        process.stderr.write(`Could not load '${loadOriginal.resolved}': ${util_1.showDownloadFailure(loadOriginal.reason)}. Skipping analysis\n`);
+        return 0;
+    }
+    LOG.debug(`Loading updated assembly from ${argv.updated}`);
+    const loadUpdated = await loadAssembly(argv.updated, argv);
+    if (!loadUpdated.success) {
+        process.stderr.write(`Could not load '${loadUpdated.resolved}': ${util_1.showDownloadFailure(loadUpdated.reason)}. Skipping analysis\n`);
+        return 0;
+    }
+    const original = loadOriginal.assembly;
+    const updated = loadUpdated.assembly;
+    if (original.name !== updated.name) {
+        process.stderr.write(`Look like different assemblies: '${original.name}' vs '${updated.name}'. Comparing is probably pointless...\n`);
+    }
+    LOG.info('Starting analysis');
+    const mismatches = lib_1.compareAssemblies(original, updated, {
+        defaultExperimental: argv['default-stability'] === 'experimental',
+    });
+    LOG.info(`Found ${mismatches.count} issues`);
+    if (mismatches.count > 0) {
+        const diags = diagnostics_1.classifyDiagnostics(mismatches, argv['experimental-errors'], await loadFilter(argv['ignore-file']));
+        process.stderr.write(`Original assembly: ${original.name}@${original.version}\n`);
+        process.stderr.write(`Updated assembly:  ${updated.name}@${updated.version}\n`);
+        process.stderr.write('API elements with incompatible changes:\n');
+        for (const diag of diags) {
+            process.stderr.write(`${diagnostics_1.formatDiagnostic(diag, argv.keys)}\n`);
+        }
+        return diagnostics_1.hasErrors(diags) ? 1 : 0;
+    }
+    return 0;
+}
+// Allow both npm:<package> (legacy) and npm://<package> (looks better)
+const NPM_REGEX = /^npm:(\/\/)?/;
+/**
+ * Load the indicated assembly from the given name
+ *
+ * Supports downloading from NPM as well as from file or directory.
+ */
+async function loadAssembly(requested, options) {
+    let resolved = requested;
+    try {
+        if (NPM_REGEX.exec(requested)) {
+            let pkg = requested.replace(NPM_REGEX, '');
+            if (!pkg) {
+                pkg = await loadPackageNameFromAssembly(options);
+            }
+            resolved = `npm://${pkg}`;
+            if (!pkg.includes('@', 1)) {
+                resolved += '@latest';
+            }
+            const download = await util_1.downloadNpmPackage(pkg, (f) => loadFromFilesystem(f, options));
+            if (download.success) {
+                return {
+                    requested,
+                    resolved,
+                    success: true,
+                    assembly: download.result,
+                };
+            }
+            return { requested, resolved, success: false, reason: download.reason };
+        }
+        // We don't accept failure loading from the filesystem
+        return {
+            requested,
+            resolved,
+            success: true,
+            assembly: await loadFromFilesystem(requested, options),
+        };
+    }
+    catch (e) {
+        // Prepend information about which assembly we've failed to load
+        //
+        // Look at the type of error. If it has a lot of lines (like validation errors
+        // tend to do) log everything to the debug log and only show a couple
+        const maxLines = 3;
+        const messageWithContext = `Error loading assembly '${resolved}': ${e.message}`;
+        const errorLines = messageWithContext.split('\n');
+        if (errorLines.length < maxLines) {
+            throw new Error(messageWithContext);
+        }
+        for (const line of errorLines) {
+            LOG.info(line);
+        }
+        throw new Error([...errorLines.slice(0, maxLines), '...'].join('\n'));
+    }
+}
+async function loadPackageNameFromAssembly(options) {
+    const JSII_ASSEMBLY_FILE = '.jsii';
+    if (!(await fs.pathExists(JSII_ASSEMBLY_FILE))) {
+        throw new Error(`No NPM package name given and no ${JSII_ASSEMBLY_FILE} file in the current directory. Please specify a package name.`);
+    }
+    const contents = await fs.readJSON(JSII_ASSEMBLY_FILE, { encoding: 'utf-8' });
+    const module = options.validate
+        ? spec.validateAssembly(contents)
+        : contents;
+    if (!module.name) {
+        throw new Error(`Could not find package in ${JSII_ASSEMBLY_FILE}`);
+    }
+    return module.name;
+}
+async function loadFromFilesystem(name, options) {
+    const stat = await fs.stat(name);
+    const ts = new reflect.TypeSystem();
+    if (stat.isDirectory()) {
+        return ts.loadModule(name, options);
+    }
+    return ts.loadFile(name, options);
+}
+main()
+    .then((n) => {
+    process.exit(n);
+})
+    .catch((e) => {
+    console.error(e);
+    process.exit(100);
+});
+function configureLog4js(verbosity) {
+    log4js.configure({
+        appenders: {
+            console: {
+                type: 'stderr',
+                layout: { type: 'colored' },
+            },
+        },
+        categories: {
+            default: { appenders: ['console'], level: _logLevel() },
+        },
+    });
+    function _logLevel() {
+        switch (verbosity) {
+            case 0:
+                return 'WARN';
+            case 1:
+                return 'INFO';
+            case 2:
+                return 'DEBUG';
+            case 3:
+                return 'TRACE';
+            default:
+                return 'ALL';
+        }
+    }
+}
+async function loadFilter(filterFilename) {
+    if (!filterFilename) {
+        return new Set();
+    }
+    try {
+        return new Set((await fs.readFile(filterFilename, { encoding: 'utf-8' }))
+            .split('\n')
+            .map((x) => x.trim())
+            .filter((x) => !x.startsWith('#')));
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT') {
+            throw e;
+        }
+        LOG.debug(`No such file: ${filterFilename}`);
+        return new Set();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsii-diff.js","sourceRoot":"","sources":["jsii-diff.ts"],"names":[],"mappings":"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","sourcesContent":["import '@jsii/check-node/run';\n\nimport * as spec from '@jsii/spec';\nimport * as fs from 'fs-extra';\nimport * as reflect from 'jsii-reflect';\nimport * as log4js from 'log4js';\nimport * as yargs from 'yargs';\n\nimport { compareAssemblies } from '../lib';\nimport {\n  classifyDiagnostics,\n  formatDiagnostic,\n  hasErrors,\n} from '../lib/diagnostics';\nimport {\n  DownloadFailure,\n  downloadNpmPackage,\n  showDownloadFailure,\n} from '../lib/util';\nimport { VERSION } from '../lib/version';\n\nconst LOG = log4js.getLogger('jsii-diff');\n\nasync function main(): Promise<number> {\n  const argv = yargs\n    .env('JSII_DIFF')\n    .option('verbose', {\n      alias: 'v',\n      type: 'count',\n      desc: 'Increase the verbosity of output',\n      global: true,\n    })\n    .option('default-stability', {\n      alias: 's',\n      type: 'string',\n      choices: ['experimental', 'stable'],\n      desc: 'Treat unmarked APIs as',\n      default: 'stable',\n    })\n    .option('experimental-errors', {\n      alias: 'e',\n      type: 'boolean',\n      default: false,\n      desc: 'Error on experimental API changes',\n    })\n    .option('ignore-file', {\n      alias: 'i',\n      type: 'string',\n      desc: 'Ignore API changes with keys from file (file may be missing)',\n    })\n    .option('keys', {\n      alias: 'k',\n      type: 'boolean',\n      default: false,\n      desc: 'Show diagnostic suppression keys',\n    })\n    .option('validate', {\n      alias: 'd',\n      type: 'boolean',\n      default: false,\n      desc: 'Validate the assemblies that are being loaded',\n    })\n    .usage('$0 <original> [updated]', 'Compare two JSII assemblies.', (args) =>\n      args\n        .positional('original', {\n          description:\n            'Original assembly (file, package or \"npm:package@version\")',\n          type: 'string',\n        })\n        .positional('updated', {\n          description: 'New assembly (file, package or \"npm:package@version\")',\n          type: 'string',\n          default: '.',\n        }),\n    )\n    .help()\n    .version(VERSION).argv;\n\n  configureLog4js(argv.verbose);\n\n  LOG.debug(`Loading original assembly from ${(argv as any).original}`);\n  const loadOriginal = await loadAssembly((argv as any).original, argv);\n  if (!loadOriginal.success) {\n    process.stderr.write(\n      `Could not load '${loadOriginal.resolved}': ${showDownloadFailure(\n        loadOriginal.reason,\n      )}. Skipping analysis\\n`,\n    );\n    return 0;\n  }\n\n  LOG.debug(`Loading updated assembly from ${(argv as any).updated}`);\n  const loadUpdated = await loadAssembly((argv as any).updated, argv);\n  if (!loadUpdated.success) {\n    process.stderr.write(\n      `Could not load '${loadUpdated.resolved}': ${showDownloadFailure(\n        loadUpdated.reason,\n      )}. Skipping analysis\\n`,\n    );\n    return 0;\n  }\n\n  const original = loadOriginal.assembly;\n  const updated = loadUpdated.assembly;\n\n  if (original.name !== updated.name) {\n    process.stderr.write(\n      `Look like different assemblies: '${original.name}' vs '${updated.name}'. Comparing is probably pointless...\\n`,\n    );\n  }\n\n  LOG.info('Starting analysis');\n  const mismatches = compareAssemblies(original, updated, {\n    defaultExperimental: argv['default-stability'] === 'experimental',\n  });\n\n  LOG.info(`Found ${mismatches.count} issues`);\n\n  if (mismatches.count > 0) {\n    const diags = classifyDiagnostics(\n      mismatches,\n      argv['experimental-errors'],\n      await loadFilter(argv['ignore-file']),\n    );\n\n    process.stderr.write(\n      `Original assembly: ${original.name}@${original.version}\\n`,\n    );\n    process.stderr.write(\n      `Updated assembly:  ${updated.name}@${updated.version}\\n`,\n    );\n    process.stderr.write('API elements with incompatible changes:\\n');\n    for (const diag of diags) {\n      process.stderr.write(`${formatDiagnostic(diag, argv.keys)}\\n`);\n    }\n\n    return hasErrors(diags) ? 1 : 0;\n  }\n\n  return 0;\n}\n\n// Allow both npm:<package> (legacy) and npm://<package> (looks better)\nconst NPM_REGEX = /^npm:(\\/\\/)?/;\n\ninterface LoadOptions {\n  validate: boolean;\n}\n\n/**\n * Load the indicated assembly from the given name\n *\n * Supports downloading from NPM as well as from file or directory.\n */\nasync function loadAssembly(\n  requested: string,\n  options: LoadOptions,\n): Promise<LoadAssemblyResult> {\n  let resolved = requested;\n  try {\n    if (NPM_REGEX.exec(requested)) {\n      let pkg = requested.replace(NPM_REGEX, '');\n      if (!pkg) {\n        pkg = await loadPackageNameFromAssembly(options);\n      }\n\n      resolved = `npm://${pkg}`;\n      if (!pkg.includes('@', 1)) {\n        resolved += '@latest';\n      }\n\n      const download = await downloadNpmPackage(pkg, (f) =>\n        loadFromFilesystem(f, options),\n      );\n      if (download.success) {\n        return {\n          requested,\n          resolved,\n          success: true,\n          assembly: download.result,\n        };\n      }\n      return { requested, resolved, success: false, reason: download.reason };\n    }\n    // We don't accept failure loading from the filesystem\n    return {\n      requested,\n      resolved,\n      success: true,\n      assembly: await loadFromFilesystem(requested, options),\n    };\n  } catch (e) {\n    // Prepend information about which assembly we've failed to load\n    //\n    // Look at the type of error. If it has a lot of lines (like validation errors\n    // tend to do) log everything to the debug log and only show a couple\n    const maxLines = 3;\n    const messageWithContext = `Error loading assembly '${resolved}': ${e.message}`;\n    const errorLines = messageWithContext.split('\\n');\n    if (errorLines.length < maxLines) {\n      throw new Error(messageWithContext);\n    }\n    for (const line of errorLines) {\n      LOG.info(line);\n    }\n    throw new Error([...errorLines.slice(0, maxLines), '...'].join('\\n'));\n  }\n}\n\ntype LoadAssemblyResult = { requested: string; resolved: string } & (\n  | { success: true; assembly: reflect.Assembly }\n  | { success: false; reason: DownloadFailure }\n);\n\nasync function loadPackageNameFromAssembly(\n  options: LoadOptions,\n): Promise<string> {\n  const JSII_ASSEMBLY_FILE = '.jsii';\n  if (!(await fs.pathExists(JSII_ASSEMBLY_FILE))) {\n    throw new Error(\n      `No NPM package name given and no ${JSII_ASSEMBLY_FILE} file in the current directory. Please specify a package name.`,\n    );\n  }\n  const contents = await fs.readJSON(JSII_ASSEMBLY_FILE, { encoding: 'utf-8' });\n  const module = options.validate\n    ? spec.validateAssembly(contents)\n    : (contents as spec.Assembly);\n  if (!module.name) {\n    throw new Error(`Could not find package in ${JSII_ASSEMBLY_FILE}`);\n  }\n\n  return module.name;\n}\n\nasync function loadFromFilesystem(name: string, options: LoadOptions) {\n  const stat = await fs.stat(name);\n\n  const ts = new reflect.TypeSystem();\n  if (stat.isDirectory()) {\n    return ts.loadModule(name, options);\n  }\n  return ts.loadFile(name, options);\n}\n\nmain()\n  .then((n) => {\n    process.exit(n);\n  })\n  .catch((e) => {\n    console.error(e);\n    process.exit(100);\n  });\n\nfunction configureLog4js(verbosity: number) {\n  log4js.configure({\n    appenders: {\n      console: {\n        type: 'stderr',\n        layout: { type: 'colored' },\n      },\n    },\n    categories: {\n      default: { appenders: ['console'], level: _logLevel() },\n    },\n  });\n\n  function _logLevel(): keyof log4js.Levels {\n    switch (verbosity) {\n      case 0:\n        return 'WARN';\n      case 1:\n        return 'INFO';\n      case 2:\n        return 'DEBUG';\n      case 3:\n        return 'TRACE';\n      default:\n        return 'ALL';\n    }\n  }\n}\n\nasync function loadFilter(filterFilename?: string): Promise<Set<string>> {\n  if (!filterFilename) {\n    return new Set();\n  }\n\n  try {\n    return new Set(\n      (await fs.readFile(filterFilename, { encoding: 'utf-8' }))\n        .split('\\n')\n        .map((x) => x.trim())\n        .filter((x) => !x.startsWith('#')),\n    );\n  } catch (e) {\n    if (e.code !== 'ENOENT') {\n      throw e;\n    }\n    LOG.debug(`No such file: ${filterFilename}`);\n    return new Set();\n  }\n}\n"]}

package/lib/diagnostics.d.ts

@@ -0,0 +1,17 @@
+import { Mismatches } from './types';
+export declare enum DiagLevel {
+    Error = 0,
+    Warning = 1,
+    Skipped = 2
+}
+export interface Diagnostic {
+    level: DiagLevel;
+    message: string;
+    suppressionKey: string;
+}
+export declare function formatDiagnostic(diag: Diagnostic, includeSuppressionKey?: boolean): string;
+export declare function hasErrors(diags: Diagnostic[]): boolean;
+/**
+ * Classify API mismatches into a set of warnings and errors
+ */
+export declare function classifyDiagnostics(mismatches: Mismatches, experimentalErrors: boolean, skipFilter: Set<string>): Diagnostic[];