jsii-diff 1.79.0 → 1.81.0

package/README.md

@@ -2,61 +2,84 @@
 
 __jsii-diff__ compares two jsii assemblies for compatibility.
 
-In the future, it will be able to do generic comparisons, but for
+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.
+with a non-zero exit code if any __stable__ or __deprecated__ 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.
+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]
+```console
+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,
+* __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
+* __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:
+```console
+jsii-diff npm:<package>
+```
+
+### Stability Error Classes
+
+By default only incompatible changes to `stable` or `deprecated` APIs are treated as errors and will fail the command.
+Changes to `experimental` or `external` APIs emit a warning.
+
+Change this behavior with the `--error-on` flag:
+
+```console
+jsii-diff npm:<package> --error-on=all
+```
+
+The following `--error-on` groups are available:
+
+| `--error-on`       | Stabilities that cause an ERROR                    |
+| ------------------ | -------------------------------------------------- |
+| `prod` (default)   | `stable`, `deprecated`                             |
+| `non-experimental` | `stable`, `deprecated`, `external`                 |
+| `all`              | `stable`, `deprecated`, `experimental`, `external` |
 
 ## 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
+__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
+* 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
+* 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
+* *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
+* 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).
+* It can *weaken* its input (require *less* from the caller); and
+* It can *strengthen* its output (guarantee *more* to the caller).
 
 ### Struct types
 
@@ -64,12 +87,12 @@ 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.
+* 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
+* 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

package/bin/jsii-diff.js

@@ -32,6 +32,13 @@ async function main() {
         type: 'boolean',
         default: false,
         desc: 'Error on experimental API changes',
+        deprecate: 'Use `--error-on` instead',
+    })
+        .option('error-on', {
+        type: 'string',
+        default: 'prod',
+        choices: diagnostics_1.ERROR_CLASSES,
+        desc: 'Which type of API changes should be treated as an error',
     })
         .option('ignore-file', {
         alias: 'i',
@@ -86,9 +93,9 @@ async function main() {
     });
     LOG.info(`Found ${mismatches.count} issues`);
     if (mismatches.count > 0) {
-        const diags = (0, diagnostics_1.classifyDiagnostics)(mismatches, argv['experimental-errors'], await loadFilter(argv['ignore-file']));
+        const diags = (0, diagnostics_1.classifyDiagnostics)(mismatches, (0, diagnostics_1.treatAsError)(argv['error-on'], 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(`Updated assembly: ${updated.name}@${updated.version}\n`);
         process.stderr.write('API elements with incompatible changes:\n');
         for (const diag of diags) {
             process.stderr.write(`${(0, diagnostics_1.formatDiagnostic)(diag, argv.keys)}\n`);

package/lib/diagnostics.d.ts

@@ -1,3 +1,4 @@
+import { Stability } from '@jsii/spec';
 import { Mismatches } from './types';
 export declare enum DiagLevel {
     Error = 0,
@@ -11,8 +12,14 @@ export interface Diagnostic {
 }
 export declare function formatDiagnostic(diag: Diagnostic, includeSuppressionKey?: boolean): string;
 export declare function hasErrors(diags: Diagnostic[]): boolean;
+export declare function onlyErrors(diags: Diagnostic[]): Diagnostic[];
+export declare function onlyWarnings(diags: Diagnostic[]): Diagnostic[];
+export declare const ERROR_CLASSES: readonly ["prod", "non-experimental", "all"];
+export declare type ErrorClass = (typeof ERROR_CLASSES)[number];
+export declare const ERROR_CLASSES_TO_STABILITIES: Record<ErrorClass, Stability[]>;
+export declare function treatAsError(errorClass: ErrorClass, deprecatedExperimentalErrors?: boolean): Set<Stability>;
 /**
  * Classify API mismatches into a set of warnings and errors
  */
-export declare function classifyDiagnostics(mismatches: Mismatches, experimentalErrors: boolean, skipFilter: Set<string>): Diagnostic[];
+export declare function classifyDiagnostics(mismatches: Mismatches, shouldError: Set<Stability>, skipFilter?: Set<string>): Diagnostic[];
 //# sourceMappingURL=diagnostics.d.ts.map

package/lib/diagnostics.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.classifyDiagnostics = exports.hasErrors = exports.formatDiagnostic = exports.DiagLevel = void 0;
+exports.classifyDiagnostics = exports.treatAsError = exports.ERROR_CLASSES_TO_STABILITIES = exports.ERROR_CLASSES = exports.onlyWarnings = exports.onlyErrors = exports.hasErrors = exports.formatDiagnostic = exports.DiagLevel = void 0;
 const spec_1 = require("@jsii/spec");
 var DiagLevel;
 (function (DiagLevel) {
@@ -26,10 +26,44 @@ function hasErrors(diags) {
     return diags.some((diag) => diag.level === DiagLevel.Error);
 }
 exports.hasErrors = hasErrors;
+function onlyErrors(diags) {
+    return diags.filter((diag) => diag.level === DiagLevel.Error);
+}
+exports.onlyErrors = onlyErrors;
+function onlyWarnings(diags) {
+    return diags.filter((diag) => diag.level === DiagLevel.Warning);
+}
+exports.onlyWarnings = onlyWarnings;
+exports.ERROR_CLASSES = ['prod', 'non-experimental', 'all'];
+exports.ERROR_CLASSES_TO_STABILITIES = {
+    prod: [spec_1.Stability.Stable, spec_1.Stability.Deprecated],
+    'non-experimental': [
+        spec_1.Stability.Stable,
+        spec_1.Stability.Deprecated,
+        spec_1.Stability.External,
+    ],
+    all: [
+        spec_1.Stability.Stable,
+        spec_1.Stability.Experimental,
+        spec_1.Stability.External,
+        spec_1.Stability.Deprecated,
+    ],
+};
+function treatAsError(errorClass, deprecatedExperimentalErrors = false) {
+    const shouldError = new Set();
+    for (const stability of exports.ERROR_CLASSES_TO_STABILITIES[errorClass]) {
+        shouldError.add(stability);
+    }
+    if (deprecatedExperimentalErrors) {
+        shouldError.add(spec_1.Stability.Experimental);
+    }
+    return shouldError;
+}
+exports.treatAsError = treatAsError;
 /**
  * Classify API mismatches into a set of warnings and errors
  */
-function classifyDiagnostics(mismatches, experimentalErrors, skipFilter) {
+function classifyDiagnostics(mismatches, shouldError, skipFilter = new Set()) {
     const ret = mismatches.mismatches.map((mis) => ({
         level: level(mis),
         message: mis.message,
@@ -41,11 +75,7 @@ function classifyDiagnostics(mismatches, experimentalErrors, skipFilter) {
         if (skipFilter.has(mis.violationKey)) {
             return DiagLevel.Skipped;
         }
-        if (mis.stability === spec_1.Stability.Stable ||
-            (mis.stability === spec_1.Stability.Experimental && experimentalErrors)) {
-            return DiagLevel.Error;
-        }
-        return DiagLevel.Warning;
+        return shouldError.has(mis.stability) ? DiagLevel.Error : DiagLevel.Warning;
     }
 }
 exports.classifyDiagnostics = classifyDiagnostics;

package/lib/version.d.ts

@@ -1,3 +1,3 @@
 /** The qualified version number for this JSII compiler. */
-export declare const VERSION = "1.79.0 (build b22f628)";
+export declare const VERSION = "1.81.0 (build 80988b0)";
 //# sourceMappingURL=version.d.ts.map

package/lib/version.js

@@ -1,7 +1,7 @@
 "use strict";
-// Generated at 2023-03-23T12:00:39Z by generate.sh
+// Generated at 2023-05-10T16:34:26Z by generate.sh
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 /** The qualified version number for this JSII compiler. */
-exports.VERSION = '1.79.0 (build b22f628)';
+exports.VERSION = '1.81.0 (build 80988b0)';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsii-diff",
-  "version": "1.79.0",
+  "version": "1.81.0",
   "description": "Assembly comparison for jsii",
   "license": "Apache-2.0",
   "author": {
@@ -33,10 +33,10 @@
     "package": "package-js"
   },
   "dependencies": {
-    "@jsii/check-node": "1.79.0",
-    "@jsii/spec": "^1.79.0",
+    "@jsii/check-node": "1.81.0",
+    "@jsii/spec": "^1.81.0",
     "fs-extra": "^10.1.0",
-    "jsii-reflect": "^1.79.0",
+    "jsii-reflect": "^1.81.0",
     "log4js": "^6.9.1",
     "yargs": "^16.2.0"
   },
@@ -44,7 +44,7 @@
     "@types/fs-extra": "^9.0.13",
     "@types/tar-fs": "^2.0.1",
     "jest-expect-message": "^1.1.3",
-    "jsii": "^1.79.0",
-    "jsii-build-tools": "^1.79.0"
+    "jsii": "^1.81.0",
+    "jsii-build-tools": "^1.81.0"
   }
 }

package/test/diagnostics.test.js

@@ -1,68 +1,106 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const spec_1 = require("@jsii/spec");
 const diagnostics_1 = require("../lib/diagnostics");
 const util_1 = require("./util");
 // ----------------------------------------------------------------------
-test('experimental elements lead to warnings', () => {
+test('experimental stability violations lead to warnings', () => {
     const mms = (0, util_1.compare)(`
     /** @experimental */
     export class Foo1 { }
   `, `
-    export class Foo2 { }
+    export class FooNew { }
   `);
-    const experimentalErrors = false;
-    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, experimentalErrors, new Set());
+    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, (0, diagnostics_1.treatAsError)('prod'));
     expect(diags.length).toBe(1);
     expect((0, diagnostics_1.hasErrors)(diags)).toBeFalsy();
 });
 // ----------------------------------------------------------------------
+test('experimental stability violations can be turned into errors', () => {
+    const mms = (0, util_1.compare)(`
+    /** @experimental */
+    export class Foo1 { }
+  `, `
+    export class FooNew { }
+  `);
+    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, (0, diagnostics_1.treatAsError)('all'));
+    expect((0, diagnostics_1.onlyErrors)(diags).length).toBe(1);
+    expect((0, diagnostics_1.onlyWarnings)(diags).length).toBe(0);
+    expect((0, diagnostics_1.hasErrors)(diags)).toBeTruthy();
+});
+// ----------------------------------------------------------------------
 test('external stability violations are reported as warnings', () => {
     const mms = (0, util_1.compare)(`
     /** @stability external */
     export class Foo1 { }
+    
   `, `
-    export class Foo2 { }
+    export class FooNew { }
   `);
-    const experimentalErrors = false;
-    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, experimentalErrors, new Set());
+    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, (0, diagnostics_1.treatAsError)('prod'));
     expect(diags.length).toBe(1);
     expect((0, diagnostics_1.hasErrors)(diags)).toBeFalsy();
 });
 // ----------------------------------------------------------------------
-test('warnings can be turned into errors', () => {
+test('external stability violations can be turned into errors', () => {
     const mms = (0, util_1.compare)(`
-    /** @experimental */
+    /** @stability external */
     export class Foo1 { }
+
+    /** @stability experimental */
+    export class Foo2 { }    
   `, `
-    export class Foo2 { }
+    export class FooNew { }
   `);
-    const experimentalErrors = true;
-    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, experimentalErrors, new Set());
-    expect(diags.length).toBe(1);
+    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, (0, diagnostics_1.treatAsError)('non-experimental'));
+    expect((0, diagnostics_1.onlyErrors)(diags).length).toBe(1);
+    expect((0, diagnostics_1.onlyWarnings)(diags).length).toBe(1);
     expect((0, diagnostics_1.hasErrors)(diags)).toBeTruthy();
 });
 // ----------------------------------------------------------------------
-test('external stability violations are never turned into errors', () => {
+test('deprecated stability violations are reported as errors', () => {
     const mms = (0, util_1.compare)(`
-    /** @stability external */
+    /** @deprecated for some reason */
     export class Foo1 { }
+    
   `, `
-    export class Foo2 { }
+    export class FooNew { }
   `);
-    const experimentalErrors = true;
-    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, experimentalErrors, new Set());
+    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, (0, diagnostics_1.treatAsError)('prod'));
     expect(diags.length).toBe(1);
-    expect((0, diagnostics_1.hasErrors)(diags)).toBeFalsy();
+    expect((0, diagnostics_1.hasErrors)(diags)).toBeTruthy();
+});
+// ----------------------------------------------------------------------
+describe('treatAsError', () => {
+    test.each([
+        ['prod', [spec_1.Stability.Deprecated, spec_1.Stability.Stable]],
+        [
+            'all',
+            [
+                spec_1.Stability.Deprecated,
+                spec_1.Stability.Experimental,
+                spec_1.Stability.External,
+                spec_1.Stability.Stable,
+            ],
+        ],
+        [
+            'non-experimental',
+            [spec_1.Stability.Deprecated, spec_1.Stability.External, spec_1.Stability.Stable],
+        ],
+    ])('%s', (errorClasses, expectedStabilities) => {
+        const shouldError = (0, diagnostics_1.treatAsError)(errorClasses);
+        expect(shouldError.size).toBe(expectedStabilities.length);
+        expect([...expectedStabilities].every((s) => shouldError.has(s))).toBe(true);
+    });
 });
 // ----------------------------------------------------------------------
-test('errors can be skipped', () => {
+test('errors can be skipped by key', () => {
     const mms = (0, util_1.compare)(`
     export class Foo1 { }
   `, `
     export class Foo2 { }
   `);
-    const experimentalErrors = true;
-    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, experimentalErrors, new Set([mms.mismatches[0].violationKey]));
+    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, (0, diagnostics_1.treatAsError)('prod'), new Set([mms.mismatches[0].violationKey]));
     expect(diags.length).toBe(1);
     expect((0, diagnostics_1.hasErrors)(diags)).toBeFalsy();
 });
@@ -75,8 +113,7 @@ test('changing stable to experimental is breaking', () => {
     /** @experimental */
     export class Foo1 { }
   `);
-    const experimentalErrors = false;
-    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, experimentalErrors, new Set());
+    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, (0, diagnostics_1.treatAsError)('prod'));
     expect(diags.length).toBeGreaterThan(0);
     expect(diags.some((d) => /stability not allowed to go from 'stable' to 'experimental'/.exec(d.message))).toBeTruthy();
     expect((0, diagnostics_1.hasErrors)(diags)).toBeTruthy();
@@ -102,8 +139,7 @@ test('can make fields optional in output struct if it is marked @external', () =
       foo(): TheStruct;
     }
     `);
-    const experimentalErrors = true;
-    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, experimentalErrors, new Set());
+    const diags = (0, diagnostics_1.classifyDiagnostics)(mms, (0, diagnostics_1.treatAsError)('prod'));
     expect(diags.length).toBe(1);
     expect((0, diagnostics_1.hasErrors)(diags)).toBeFalsy();
 });