jsii-diff 1.35.0

package/lib/types.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeInterfaceType = exports.describeType = exports.apiElementIdentifier = exports.Mismatches = void 0;
+const reflect = require("jsii-reflect");
+class Mismatches {
+    constructor(opts) {
+        this.mismatches = new Array();
+        this.defaultStability = opts.defaultStability;
+    }
+    report(options) {
+        var _a;
+        const fqn = apiElementIdentifier(options.violator);
+        const key = `${options.ruleKey}:${fqn}`;
+        this.mismatches.push({
+            violationKey: key,
+            message: `${describeApiElement(options.violator)} ${fqn}: ${options.message}`,
+            stability: (_a = options.violator.docs.stability) !== null && _a !== void 0 ? _a : this.defaultStability,
+        });
+    }
+    *messages() {
+        for (const mis of this.mismatches) {
+            yield mis.message;
+        }
+    }
+    get count() {
+        return this.mismatches.length;
+    }
+    filter(pred) {
+        const ret = new Mismatches({ defaultStability: this.defaultStability });
+        ret.mismatches.push(...this.mismatches.filter(pred));
+        return ret;
+    }
+    withMotivation(motivation) {
+        return {
+            report: (options) => this.report({
+                ...options,
+                message: `${options.message}: ${motivation}`,
+            }),
+            withMotivation: (innerMotivation) => this.withMotivation(`${innerMotivation}: ${motivation}`),
+        };
+    }
+}
+exports.Mismatches = Mismatches;
+function apiElementIdentifier(apiElement) {
+    return dispatch(apiElement, {
+        method(x) {
+            return `${x.parentType.fqn}.${x.name}`;
+        },
+        init(x) {
+            return `${x.parentType.fqn}.${x.name}`;
+        },
+        property(x) {
+            return `${x.parentType.fqn}.${x.name}`;
+        },
+        enumMember(x) {
+            return `${x.enumType.fqn}.${x.name}`;
+        },
+        enumType(x) {
+            return `${x.fqn}`;
+        },
+        klass(x) {
+            return `${x.fqn}`;
+        },
+        iface(x) {
+            return `${x.fqn}`;
+        },
+    });
+}
+exports.apiElementIdentifier = apiElementIdentifier;
+function describeApiElement(apiElement) {
+    return dispatch(apiElement, {
+        method() {
+            return 'METHOD';
+        },
+        init() {
+            return 'INITIALIZER';
+        },
+        property() {
+            return 'PROP';
+        },
+        enumMember() {
+            return 'ENUM VALUE';
+        },
+        enumType() {
+            return 'ENUM';
+        },
+        klass() {
+            return 'CLASS';
+        },
+        iface() {
+            return 'IFACE';
+        },
+    });
+}
+function dispatch(apiElement, fns) {
+    if (apiElement instanceof reflect.Method) {
+        return fns.method(apiElement);
+    }
+    if (apiElement instanceof reflect.Property) {
+        return fns.property(apiElement);
+    }
+    if (apiElement instanceof reflect.EnumMember) {
+        return fns.enumMember(apiElement);
+    }
+    if (apiElement instanceof reflect.ClassType) {
+        return fns.klass(apiElement);
+    }
+    if (apiElement instanceof reflect.InterfaceType) {
+        return fns.iface(apiElement);
+    }
+    if (apiElement instanceof reflect.Initializer) {
+        return fns.init(apiElement);
+    }
+    if (apiElement instanceof reflect.EnumType) {
+        return fns.enumType(apiElement);
+    }
+    throw new Error(`Unrecognized violator: ${apiElement.toString()}`);
+}
+function describeType(type) {
+    if (type.isClassType()) {
+        return 'CLASS';
+    }
+    if (type.isInterfaceType()) {
+        return 'IFACE';
+    }
+    if (type.isEnumType()) {
+        return 'ENUM';
+    }
+    return 'TYPE';
+}
+exports.describeType = describeType;
+function describeInterfaceType(dataType) {
+    return dataType ? 'struct' : 'regular interface';
+}
+exports.describeInterfaceType = describeInterfaceType;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stability } from '@jsii/spec';\nimport * as reflect from 'jsii-reflect';\n\nexport interface ComparisonOptions {\n  /**\n   * Whether to treat API elements as experimental if unmarked.\n   *\n   * @default Treat as stable\n   */\n  defaultExperimental?: boolean;\n}\n\nexport interface ComparisonContext extends ComparisonOptions {\n  /**\n   * Where to report errors\n   */\n  mismatches: Mismatches;\n}\n\nexport interface ApiMismatch {\n  message: string;\n  violationKey: string;\n  stability: Stability;\n}\n\nexport type ApiElement = reflect.Type | reflect.TypeMember | reflect.EnumMember;\n\nexport interface ReportOptions {\n  ruleKey: string;\n  violator: ApiElement;\n  message: string;\n}\n\nexport interface IReport {\n  report(options: ReportOptions): void;\n  withMotivation(reason: string): IReport;\n}\n\nexport class Mismatches implements IReport {\n  public readonly mismatches = new Array<ApiMismatch>();\n  private readonly defaultStability: Stability;\n\n  public constructor(opts: { defaultStability: Stability }) {\n    this.defaultStability = opts.defaultStability;\n  }\n\n  public report(options: ReportOptions) {\n    const fqn = apiElementIdentifier(options.violator);\n    const key = `${options.ruleKey}:${fqn}`;\n\n    this.mismatches.push({\n      violationKey: key,\n      message: `${describeApiElement(options.violator)} ${fqn}: ${\n        options.message\n      }`,\n      stability: options.violator.docs.stability ?? this.defaultStability,\n    });\n  }\n\n  public *messages() {\n    for (const mis of this.mismatches) {\n      yield mis.message;\n    }\n  }\n\n  public get count() {\n    return this.mismatches.length;\n  }\n\n  public filter(pred: (x: ApiMismatch) => boolean): Mismatches {\n    const ret = new Mismatches({ defaultStability: this.defaultStability });\n    ret.mismatches.push(...this.mismatches.filter(pred));\n    return ret;\n  }\n\n  public withMotivation(motivation: string): IReport {\n    return {\n      report: (options) =>\n        this.report({\n          ...options,\n          message: `${options.message}: ${motivation}`,\n        }),\n      withMotivation: (innerMotivation) =>\n        this.withMotivation(`${innerMotivation}: ${motivation}`),\n    };\n  }\n}\n\nexport function apiElementIdentifier(apiElement: ApiElement) {\n  return dispatch(apiElement, {\n    method(x) {\n      return `${x.parentType.fqn}.${x.name}`;\n    },\n    init(x) {\n      return `${x.parentType.fqn}.${x.name}`;\n    },\n    property(x) {\n      return `${x.parentType.fqn}.${x.name}`;\n    },\n    enumMember(x) {\n      return `${x.enumType.fqn}.${x.name}`;\n    },\n    enumType(x) {\n      return `${x.fqn}`;\n    },\n    klass(x) {\n      return `${x.fqn}`;\n    },\n    iface(x) {\n      return `${x.fqn}`;\n    },\n  });\n}\n\nfunction describeApiElement(apiElement: ApiElement) {\n  return dispatch(apiElement, {\n    method() {\n      return 'METHOD';\n    },\n    init() {\n      return 'INITIALIZER';\n    },\n    property() {\n      return 'PROP';\n    },\n    enumMember() {\n      return 'ENUM VALUE';\n    },\n    enumType() {\n      return 'ENUM';\n    },\n    klass() {\n      return 'CLASS';\n    },\n    iface() {\n      return 'IFACE';\n    },\n  });\n}\n\nfunction dispatch<T>(\n  apiElement: ApiElement,\n  fns: {\n    method(m: reflect.Method): T;\n    init(m: reflect.Initializer): T;\n    property(m: reflect.Property): T;\n    enumMember(m: reflect.EnumMember): T;\n    enumType(m: reflect.EnumType): T;\n    klass(m: reflect.ClassType): T;\n    iface(m: reflect.InterfaceType): T;\n  },\n) {\n  if (apiElement instanceof reflect.Method) {\n    return fns.method(apiElement);\n  }\n  if (apiElement instanceof reflect.Property) {\n    return fns.property(apiElement);\n  }\n  if (apiElement instanceof reflect.EnumMember) {\n    return fns.enumMember(apiElement);\n  }\n  if (apiElement instanceof reflect.ClassType) {\n    return fns.klass(apiElement);\n  }\n  if (apiElement instanceof reflect.InterfaceType) {\n    return fns.iface(apiElement);\n  }\n  if (apiElement instanceof reflect.Initializer) {\n    return fns.init(apiElement);\n  }\n  if (apiElement instanceof reflect.EnumType) {\n    return fns.enumType(apiElement);\n  }\n\n  throw new Error(`Unrecognized violator: ${apiElement.toString()}`);\n}\n\nexport function describeType(type: reflect.Type) {\n  if (type.isClassType()) {\n    return 'CLASS';\n  }\n  if (type.isInterfaceType()) {\n    return 'IFACE';\n  }\n  if (type.isEnumType()) {\n    return 'ENUM';\n  }\n  return 'TYPE';\n}\n\nexport function describeInterfaceType(dataType: boolean) {\n  return dataType ? 'struct' : 'regular interface';\n}\n"]}

package/lib/util.d.ts

@@ -0,0 +1,19 @@
+export declare function inTempDir<T>(block: () => T | Promise<T>): Promise<T>;
+export declare type DownloadFailure = 'no_such_package';
+export declare type NpmDownloadResult<T> = {
+    success: true;
+    result: T;
+} | {
+    success: false;
+    reason: DownloadFailure;
+};
+export declare function showDownloadFailure(f: DownloadFailure): "NPM package does not exist" | undefined;
+export declare function downloadNpmPackage<T>(pkg: string, block: (dir: string) => Promise<T>): Promise<NpmDownloadResult<T>>;
+export declare function flatMap<T, U>(xs: T[], fn: (x: T) => U[]): U[];
+/**
+ * Don't recurse infinitely by guarding a block with `do()`.
+ */
+export declare class RecursionBreaker<A> {
+    private readonly elements;
+    do(key: A, block: () => void): void;
+}

package/lib/util.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecursionBreaker = exports.flatMap = exports.downloadNpmPackage = exports.showDownloadFailure = exports.inTempDir = void 0;
+const childProcess = require("child_process");
+const fs = require("fs-extra");
+const log4js = require("log4js");
+const os = require("os");
+const path = require("path");
+const util = require("util");
+const LOG = log4js.getLogger('jsii-diff');
+const exec = util.promisify(childProcess.exec);
+async function inTempDir(block) {
+    const origDir = process.cwd();
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'jsii'));
+    process.chdir(tmpDir);
+    try {
+        return await block();
+    }
+    finally {
+        process.chdir(origDir);
+        await fs.remove(tmpDir);
+    }
+}
+exports.inTempDir = inTempDir;
+function showDownloadFailure(f) {
+    switch (f) {
+        case 'no_such_package':
+            return 'NPM package does not exist';
+        default:
+            return undefined;
+    }
+}
+exports.showDownloadFailure = showDownloadFailure;
+async function downloadNpmPackage(pkg, block) {
+    return inTempDir(async () => {
+        LOG.info(`Fetching NPM package ${pkg}`);
+        try {
+            // Need to install package and dependencies in order for jsii-reflect
+            // to not bork when it can find the dependencies.
+            await exec(`npm install --silent --prefix . ${pkg}`);
+        }
+        catch (e) {
+            // If this fails, might be because the package doesn't exist
+            if (!isSubprocesFailedError(e)) {
+                throw e;
+            }
+            if (await npmPackageExists(pkg)) {
+                throw new Error(`NPM fetch failed: ${e}. Please try again.`);
+            }
+            LOG.warn(`NPM package ${pkg} does not exist.`);
+            return {
+                success: false,
+                reason: 'no_such_package',
+            };
+        }
+        const pkgDir = trimVersionString(pkg);
+        return {
+            success: true,
+            result: await block(path.join(process.cwd(), 'node_modules', pkgDir)),
+        };
+    });
+}
+exports.downloadNpmPackage = downloadNpmPackage;
+function isSubprocesFailedError(e) {
+    return e.code !== undefined && e.cmd !== undefined;
+}
+async function npmPackageExists(pkg) {
+    try {
+        LOG.info(`Checking existence of ${pkg}`);
+        await exec(`npm show --silent ${pkg}`);
+        return true;
+    }
+    catch (e) {
+        if (!isSubprocesFailedError(e)) {
+            throw e;
+        }
+        return false;
+    }
+}
+/**
+ * Trim an optional version string from an NPM package name
+ */
+function trimVersionString(pkg) {
+    // The arbitrary char before the @ prevents matching a @ at the start of the
+    // string.
+    return pkg.replace(/(.)@.*$/, '$1');
+}
+function flatMap(xs, fn) {
+    const ret = new Array();
+    for (const x of xs) {
+        ret.push(...fn(x));
+    }
+    return ret;
+}
+exports.flatMap = flatMap;
+/**
+ * Don't recurse infinitely by guarding a block with `do()`.
+ */
+class RecursionBreaker {
+    constructor() {
+        this.elements = new Set();
+    }
+    do(key, block) {
+        if (this.elements.has(key)) {
+            return;
+        }
+        this.elements.add(key);
+        try {
+            block();
+        }
+        finally {
+            this.elements.delete(key);
+        }
+    }
+}
+exports.RecursionBreaker = RecursionBreaker;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["util.ts"],"names":[],"mappings":"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","sourcesContent":["import * as childProcess from 'child_process';\nimport * as fs from 'fs-extra';\nimport * as log4js from 'log4js';\nimport * as os from 'os';\nimport * as path from 'path';\nimport * as util from 'util';\n\nconst LOG = log4js.getLogger('jsii-diff');\n\nconst exec = util.promisify(childProcess.exec);\n\nexport async function inTempDir<T>(block: () => T | Promise<T>): Promise<T> {\n  const origDir = process.cwd();\n  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'jsii'));\n  process.chdir(tmpDir);\n  try {\n    return await block();\n  } finally {\n    process.chdir(origDir);\n    await fs.remove(tmpDir);\n  }\n}\n\nexport type DownloadFailure = 'no_such_package';\n\nexport type NpmDownloadResult<T> =\n  | { success: true; result: T }\n  | { success: false; reason: DownloadFailure };\n\nexport function showDownloadFailure(f: DownloadFailure) {\n  switch (f) {\n    case 'no_such_package':\n      return 'NPM package does not exist';\n    default:\n      return undefined;\n  }\n}\n\nexport async function downloadNpmPackage<T>(\n  pkg: string,\n  block: (dir: string) => Promise<T>,\n): Promise<NpmDownloadResult<T>> {\n  return inTempDir(async () => {\n    LOG.info(`Fetching NPM package ${pkg}`);\n\n    try {\n      // Need to install package and dependencies in order for jsii-reflect\n      // to not bork when it can find the dependencies.\n      await exec(`npm install --silent --prefix . ${pkg}`);\n    } catch (e) {\n      // If this fails, might be because the package doesn't exist\n      if (!isSubprocesFailedError(e)) {\n        throw e;\n      }\n      if (await npmPackageExists(pkg)) {\n        throw new Error(`NPM fetch failed: ${e}. Please try again.`);\n      }\n      LOG.warn(`NPM package ${pkg} does not exist.`);\n      return {\n        success: false,\n        reason: 'no_such_package',\n      } as NpmDownloadResult<T>;\n    }\n\n    const pkgDir = trimVersionString(pkg);\n    return {\n      success: true,\n      result: await block(path.join(process.cwd(), 'node_modules', pkgDir)),\n    } as NpmDownloadResult<T>;\n  });\n}\n\nfunction isSubprocesFailedError(e: any) {\n  return e.code !== undefined && e.cmd !== undefined;\n}\n\nasync function npmPackageExists(pkg: string): Promise<boolean> {\n  try {\n    LOG.info(`Checking existence of ${pkg}`);\n    await exec(`npm show --silent ${pkg}`);\n    return true;\n  } catch (e) {\n    if (!isSubprocesFailedError(e)) {\n      throw e;\n    }\n    return false;\n  }\n}\n\n/**\n * Trim an optional version string from an NPM package name\n */\nfunction trimVersionString(pkg: string) {\n  // The arbitrary char before the @ prevents matching a @ at the start of the\n  // string.\n  return pkg.replace(/(.)@.*$/, '$1');\n}\n\nexport function flatMap<T, U>(xs: T[], fn: (x: T) => U[]): U[] {\n  const ret = new Array<U>();\n  for (const x of xs) {\n    ret.push(...fn(x));\n  }\n  return ret;\n}\n\n/**\n * Don't recurse infinitely by guarding a block with `do()`.\n */\nexport class RecursionBreaker<A> {\n  private readonly elements = new Set<A>();\n\n  public do(key: A, block: () => void) {\n    if (this.elements.has(key)) {\n      return;\n    }\n\n    this.elements.add(key);\n    try {\n      block();\n    } finally {\n      this.elements.delete(key);\n    }\n  }\n}\n"]}

package/lib/validations.d.ts

@@ -0,0 +1,157 @@
+import * as reflect from 'jsii-reflect';
+import { IReport } from './types';
+/**
+ * The updated type is still nominally assignable to all original base types
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * BASE instance = new CLASS();
+ * ```
+ *
+ * Where CLASS ≤: BASE.
+ */
+export declare function validateBaseTypeAssignability<T extends reflect.ReferenceType>(original: T, updated: T, mismatches: IReport): void;
+/**
+ * The updated type has not been newly made abstract
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * new CLASS();
+ * ```
+ */
+export declare function validateNotMadeAbstract(original: reflect.ClassType, updated: reflect.ClassType, mismatches: IReport): void;
+/**
+ * The updated type has not had its @subclassable attribute removed
+ *
+ * This would lift a restriction we can't afford.
+ */
+export declare function validateSubclassableNotRemoved<T extends reflect.ReferenceType>(original: T, updated: T, mismatches: IReport): void;
+/**
+ * Check that the `static`-ness of a member hasn't changed
+ */
+export declare function validateStaticSame<T extends reflect.Method | reflect.Property>(original: T, updated: T, mismatches: IReport): void;
+/**
+ * Check that the `async`-ness of a method hasn't changed
+ */
+export declare function validateAsyncSame(original: reflect.Method, updated: reflect.Method, mismatches: IReport): void;
+/**
+ * Once variadic, can never be made non-variadic anymore (because I could always have been passing N+1 arguments)
+ */
+export declare function validateNotMadeNonVariadic<T extends reflect.Method | reflect.Initializer>(original: T, updated: T, mismatches: IReport): void;
+/**
+ * Check that no new abstract members were added to a subclassable type
+ *
+ * You cannot have added abstract members to the class/interface, as they are
+ * an added burden on potential implementors.
+ */
+export declare function validateNoNewAbstractMembers<T extends reflect.ReferenceType>(original: T, updated: T, mismatches: IReport): void;
+/**
+ * Validate that a method return type is the same or strengthened
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * T value = object.method();
+ * ```
+ *
+ * Where RETURN_TYPE(method) ≤: T.
+ */
+export declare function validateReturnTypeNotWeakened(original: reflect.Method, updated: reflect.Method, mismatches: IReport): void;
+/**
+ * Validate that a method return type is the exact same
+ *
+ * Necessary for subclassable types in C#.
+ */
+export declare function validateReturnTypeSame(original: reflect.Method, updated: reflect.Method, mismatches: IReport): void;
+/**
+ * Validate that a property type is the same or strengthened
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * T value = object.prop;
+ * ```
+ *
+ * Where RETURN_TYPE(prop) ≤: T.
+ */
+export declare function validatePropertyTypeNotWeakened(original: reflect.Property, updated: reflect.Property, mismatches: IReport): void;
+/**
+ * Validate that a property type is the exact same
+ *
+ * Necessary for subclassable types in C#.
+ */
+export declare function validatePropertyTypeSame(original: reflect.Property, updated: reflect.Property, mismatches: IReport): void;
+/**
+ * Validate that a method return type is the same or weakened
+ *
+ * Make sure the following remains compilable if U is changed:
+ *
+ * ```
+ * function method(arg: U) { ... }
+ *
+ * object.method(<T>value);
+ * ```
+ *
+ * Where T ≤: U.
+ */
+export declare function validateParameterTypeWeakened(method: reflect.Method | reflect.Initializer, original: reflect.Parameter, updated: reflect.Parameter, mismatches: IReport): void;
+/**
+ * Validate that a method parameter type is the exact same
+ *
+ * Necessary for subclassable types in C#.
+ */
+export declare function validateParameterTypeSame(method: reflect.Method | reflect.Initializer, original: reflect.Parameter, updated: reflect.Parameter, mismatches: IReport): void;
+/**
+ * Validate that each param in the old callable is still available in the new callable, and apply custom validation to the pairs
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * object.method(a1, a2, ..., aN);
+ * ```
+ *
+ * (All types still assignable)
+ */
+export declare function validateExistingParams<T extends reflect.Initializer | reflect.Method>(original: T, updated: T, mismatches: IReport, validateParam: (oldParam: reflect.Parameter, newParam: reflect.Parameter) => void): void;
+/**
+ * Validate that no new required params got added to the end of the method
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * object.method(a1, a2, ..., aN);
+ * ```
+ *
+ * (Not too few arguments)
+ */
+export declare function validateNoNewRequiredParams<T extends reflect.Initializer | reflect.Method>(original: T, updated: T, mismatches: IReport): void;
+export declare function validateMethodCompatible<T extends reflect.Method | reflect.Initializer>(original: T, updated: T, mismatches: IReport): void;
+/**
+ * Check if a class/interface has been marked as @subclassable
+ */
+export declare function subclassableType(x: reflect.Documentable): boolean;
+/**
+ * Validate that a previously mutable property is not made immutable
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * object.prop = value;
+ * ```
+ */
+export declare function validateNotMadeImmutable(original: reflect.Property, updated: reflect.Property, mismatches: IReport): void;
+export declare function memberPairs<T extends reflect.TypeMember, U extends reflect.ReferenceType>(origClass: U, xs: T[], updatedClass: U, mismatches: IReport): IterableIterator<[T, reflect.TypeMember]>;
+/**
+ * Validate that each enum member in the old enum enum, and apply custom validation to the enums
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * T x = ENUM.member;
+ * ```
+ *
+ * (For every member of enum)
+ */
+export declare function validateExistingMembers(original: reflect.EnumType, updated: reflect.EnumType, mismatches: IReport, validateMember: (oldParam: reflect.EnumMember, newParam: reflect.EnumMember) => void): void;