@cdklabs/eslint-plugin 0.0.0

package/lib/rules/invalid-cfn-imports.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+const type_checkers_1 = require("../private/type-checkers");
+let namespaceImports = {};
+function create(context) {
+    // The format of Cfn imports only matters for alpha packages, so that they can be
+    // formatted correctly when released separately for V2. The linter rule should only be
+    // applied if the file is in an alpha package, or it is a test file.
+    const filename = context.getFilename();
+    if (!currentFileIsInAlphaPackage(filename) && !filename.match('test/rules/fixtures')) {
+        return {};
+    }
+    return {
+        ImportDeclaration: node => {
+            const location = node.source.value;
+            // Store all of the 'import * as name from location' imports, so that we can check the location when
+            // we find name.CfnXXX references.
+            node.specifiers.forEach(e => {
+                if (e.type === 'ImportNamespaceSpecifier') {
+                    namespaceImports[e.local.name] = location;
+                }
+            });
+            if (location.endsWith('generated') || location === '@aws-cdk/core') {
+                // If importing directly from a generated file, this is fine. Also we know that aws-cdk/core is not experimental, so that is fine as well.
+                return;
+            }
+            const cfnImports = [];
+            const otherImports = [];
+            node.specifiers.forEach(e => {
+                if (e.type === 'ImportSpecifier' && (0, type_checkers_1.isIdentifier)(e.imported)) {
+                    if (e.imported.name.startsWith('Cfn')) {
+                        cfnImports.push(e);
+                    }
+                    else {
+                        otherImports.push(e);
+                    }
+                }
+            });
+            if (cfnImports.length > 0 && otherImports.length > 0 && location.startsWith('.')) {
+                // import { CfnXXX, SomethingElse, AnotherThing } from './some/relative/path/not/ending/in/generated';
+                context.report({
+                    message: 'To allow rewriting imports when generating v2 experimental packages, import of `' + cfnImports.map(e => e.imported.name).join(', ') + '` must be separate from import of `' + otherImports.map(e => e.imported.name).join(', ') + '`, and imported from its specific .generated location.',
+                    node: node,
+                });
+            }
+            else if (cfnImports.length > 0 && location.startsWith('.')) {
+                // import { CfnXXX } from './some/relative/path/not/ending/in/generated';
+                context.report({
+                    message: 'To allow rewriting imports when generating v2 experimental packages, import of `' + cfnImports.map(e => e.imported.name).join(', ') + '` must be imported from its specific .generated location.',
+                    node: node,
+                });
+            }
+            else if (cfnImports.length > 0 && otherImports.length > 0 && checkIfImportedLocationIsAnAlphaPackage(location)) {
+                // import { CfnXXX, SomethingElse, AnotherThing } from '@aws-cdk/another-alpha-package';
+                context.report({
+                    message: 'To allow rewriting imports when generating v2 experimental packages, import of `' + cfnImports.map(e => e.imported.name).join(', ') + '` must be separate from import of `' + otherImports.map(e => e.imported.name).join(', ') + '`',
+                    node: node,
+                });
+            }
+        },
+        // This captures using `xxx.CfnConstruct` as an identifier
+        Identifier: node => {
+            var _a;
+            const typeAnnotation = (_a = node.typeAnnotation) === null || _a === void 0 ? void 0 : _a.typeAnnotation;
+            const type = typeAnnotation === null || typeAnnotation === void 0 ? void 0 : typeAnnotation.typeName;
+            if ((type === null || type === void 0 ? void 0 : type.type) === 'TSQualifiedName') {
+                const result = checkLeftAndRightForCfn(type);
+                if (result) {
+                    reportErrorIfImportedLocationIsNotValid(context, node, result.name, result.location);
+                }
+            }
+            if (node.name.startsWith('Cfn') && node.parent.type === 'MemberExpression' && node.parent.object.type === 'Identifier') {
+                // new xxx.CfnConstruct();
+                reportErrorIfImportedLocationIsNotValid(context, node, node.name, node.parent.object.name);
+            }
+        },
+    };
+}
+function reportErrorIfImportedLocationIsNotValid(context, node, name, barrelImportName) {
+    const location = namespaceImports[barrelImportName];
+    if (!location) {
+        // This scenario should not happen, but if it does, we don't want users to run into weird runtime errors from the linter.
+        return;
+    }
+    if (location.endsWith('generated') || location === '@aws-cdk/core') {
+        return;
+    }
+    if (location.startsWith('.')) {
+        // import * as name from './some/relative/path/not/ending/in/generated'; name.CfnConstruct();
+        context.report({
+            message: 'To allow rewriting imports when generating v2 experimental packages, `' + name + '` must be imported by name from its specific .generated location.',
+            node: node,
+        });
+    }
+    else if (checkIfImportedLocationIsAnAlphaPackage(location)) {
+        // import * as name from '@aws-cdk/another-alpha-package'; name.CfnConstruct();
+        context.report({
+            message: 'To allow rewriting imports when generating v2 experimental packages, `' + name + '` must be imported by name and separate from non-L1 imports, since it is being imported from an experimental package: ' + location,
+            node: node,
+        });
+    }
+}
+const ALPHA_RE = /@aws-cdk(\/|\\)[a-z0-9-]+-alpha/i;
+function currentFileIsInAlphaPackage(filename) {
+    return ALPHA_RE.test(filename);
+}
+function checkIfImportedLocationIsAnAlphaPackage(location) {
+    return ALPHA_RE.test(location);
+}
+function checkLeftAndRightForCfn(node) {
+    var _a, _b;
+    // Checking the left and right allows capturing the CfnConstruct name even if the TSQualifiedName references a subtype like:
+    //    xxx.CfnConstruct.subtype
+    //    xxx.CfnConstruct.subtype.anothersubtype
+    if (!node) {
+        return undefined;
+    }
+    if ((_a = node.name) === null || _a === void 0 ? void 0 : _a.startsWith('Cfn')) {
+        if (node.name === node.parent.left.name) {
+            // This is the scenario for a reference to CfnConstruct.subtype
+            // In this case, it is not qualified with a barrel import, so we don't need to do anything.
+            return undefined;
+        }
+        return {
+            name: node.name,
+            location: node.parent.left.name,
+        };
+    }
+    const right = checkLeftAndRightForCfn(node.right);
+    const left = checkLeftAndRightForCfn(node.left);
+    return (_b = right !== null && right !== void 0 ? right : left) !== null && _b !== void 0 ? _b : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"invalid-cfn-imports.js","sourceRoot":"","sources":["../../src/rules/invalid-cfn-imports.ts"],"names":[],"mappings":"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","sourcesContent":["import { Rule } from 'eslint';\nimport type { Identifier, ImportSpecifier } from 'estree';\nimport { isIdentifier } from '../private/type-checkers';\n\nlet namespaceImports: {\n  [key: string]: string;\n} = {};\n\nexport function create(context: Rule.RuleContext): Rule.NodeListener {\n  // The format of Cfn imports only matters for alpha packages, so that they can be\n  // formatted correctly when released separately for V2. The linter rule should only be\n  // applied if the file is in an alpha package, or it is a test file.\n  const filename = context.getFilename();\n  if (!currentFileIsInAlphaPackage(filename) && !filename.match('test/rules/fixtures')) {\n    return {};\n  }\n\n  return {\n    ImportDeclaration: node => {\n      const location = node.source.value as string;\n      // Store all of the 'import * as name from location' imports, so that we can check the location when\n      // we find name.CfnXXX references.\n      node.specifiers.forEach(e => {\n        if (e.type === 'ImportNamespaceSpecifier') {\n          namespaceImports[e.local.name] = location;\n        }\n      });\n\n      if (location.endsWith('generated') || location === '@aws-cdk/core') {\n        // If importing directly from a generated file, this is fine. Also we know that aws-cdk/core is not experimental, so that is fine as well.\n        return;\n      }\n\n      // ImportSpecifiers can also contain literals.\n      type ImportSpecifierWIdentifier = Omit<ImportSpecifier, 'imported'> & { imported: Identifier };\n\n      const cfnImports: ImportSpecifierWIdentifier[] = [];\n      const otherImports: ImportSpecifierWIdentifier[] = [];\n      node.specifiers.forEach(e => {\n        if (e.type === 'ImportSpecifier' && isIdentifier(e.imported)) {\n          if (e.imported.name.startsWith('Cfn')) {\n            cfnImports.push(e as any);\n          } else {\n            otherImports.push(e as any);\n          }\n        }\n      });\n\n      if (cfnImports.length > 0 && otherImports.length > 0 && location.startsWith('.')) {\n        // import { CfnXXX, SomethingElse, AnotherThing } from './some/relative/path/not/ending/in/generated';\n        context.report({\n          message: 'To allow rewriting imports when generating v2 experimental packages, import of `' + cfnImports.map(e => e.imported.name).join(', ') + '` must be separate from import of `' + otherImports.map(e => e.imported.name).join(', ') + '`, and imported from its specific .generated location.',\n          node: node,\n        });\n      } else if (cfnImports.length > 0 && location.startsWith('.')) {\n        // import { CfnXXX } from './some/relative/path/not/ending/in/generated';\n        context.report({\n          message: 'To allow rewriting imports when generating v2 experimental packages, import of `' + cfnImports.map(e => e.imported.name).join(', ') + '` must be imported from its specific .generated location.',\n          node: node,\n        });\n      } else if (cfnImports.length > 0 && otherImports.length > 0 && checkIfImportedLocationIsAnAlphaPackage(location)) {\n        // import { CfnXXX, SomethingElse, AnotherThing } from '@aws-cdk/another-alpha-package';\n        context.report({\n          message: 'To allow rewriting imports when generating v2 experimental packages, import of `' + cfnImports.map(e => e.imported.name).join(', ') + '` must be separate from import of `' + otherImports.map(e => e.imported.name).join(', ') + '`',\n          node: node,\n        });\n      }\n    },\n\n    // This captures using `xxx.CfnConstruct` as an identifier\n    Identifier: node => {\n      const typeAnnotation = (node as any).typeAnnotation?.typeAnnotation;\n      const type = typeAnnotation?.typeName;\n      if (type?.type === 'TSQualifiedName') {\n        const result = checkLeftAndRightForCfn(type);\n        if (result) {\n          reportErrorIfImportedLocationIsNotValid(context, node, result.name, result.location);\n        }\n      }\n      if (node.name.startsWith('Cfn') && node.parent.type === 'MemberExpression' && node.parent.object.type === 'Identifier') {\n        // new xxx.CfnConstruct();\n        reportErrorIfImportedLocationIsNotValid(context, node, node.name, node.parent.object.name);\n      }\n    },\n  };\n}\n\nfunction reportErrorIfImportedLocationIsNotValid(context: Rule.RuleContext, node: Identifier, name: string, barrelImportName: string) {\n  const location = namespaceImports[barrelImportName];\n  if (!location) {\n    // This scenario should not happen, but if it does, we don't want users to run into weird runtime errors from the linter.\n    return;\n  }\n  if (location.endsWith('generated') || location === '@aws-cdk/core') {\n    return;\n  }\n  if (location.startsWith('.')) {\n    // import * as name from './some/relative/path/not/ending/in/generated'; name.CfnConstruct();\n    context.report({\n      message: 'To allow rewriting imports when generating v2 experimental packages, `' + name + '` must be imported by name from its specific .generated location.',\n      node: node,\n    });\n  } else if (checkIfImportedLocationIsAnAlphaPackage(location)) {\n    // import * as name from '@aws-cdk/another-alpha-package'; name.CfnConstruct();\n    context.report({\n      message: 'To allow rewriting imports when generating v2 experimental packages, `' + name + '` must be imported by name and separate from non-L1 imports, since it is being imported from an experimental package: ' + location,\n      node: node,\n    });\n  }\n}\n\nconst ALPHA_RE = /@aws-cdk(\\/|\\\\)[a-z0-9-]+-alpha/i;\n\nfunction currentFileIsInAlphaPackage(filename: string): boolean {\n  return ALPHA_RE.test(filename);\n}\n\nfunction checkIfImportedLocationIsAnAlphaPackage(location: string): boolean {\n  return ALPHA_RE.test(location);\n}\n\nfunction checkLeftAndRightForCfn(node: any): { name: string; location: string } | undefined {\n  // Checking the left and right allows capturing the CfnConstruct name even if the TSQualifiedName references a subtype like:\n  //    xxx.CfnConstruct.subtype\n  //    xxx.CfnConstruct.subtype.anothersubtype\n  if (!node) {\n    return undefined;\n  }\n  if (node.name?.startsWith('Cfn')) {\n    if (node.name === node.parent.left.name) {\n      // This is the scenario for a reference to CfnConstruct.subtype\n      // In this case, it is not qualified with a barrel import, so we don't need to do anything.\n      return undefined;\n    }\n    return {\n      name: node.name,\n      location: node.parent.left.name,\n    };\n  }\n\n  const right = checkLeftAndRightForCfn(node.right);\n  const left = checkLeftAndRightForCfn(node.left);\n\n  return right ?? left ?? undefined;\n}\n"]}

package/lib/rules/no-core-construct.d.ts

@@ -0,0 +1,5 @@
+import { Rule } from 'eslint';
+export declare const meta: {
+    fixable: boolean;
+};
+export declare function create(context: Rule.RuleContext): Rule.NodeListener;

package/lib/rules/no-core-construct.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meta = void 0;
+exports.create = create;
+const import_cache_1 = require("../private/import-cache");
+let importCache;
+let importsFixed;
+const BANNED_TYPES = ['IConstruct', 'Construct'];
+exports.meta = {
+    fixable: true,
+};
+function create(context) {
+    return {
+        // `node` is a type from @typescript-eslint/typescript-estree, but using 'any' for now
+        // since it's incompatible with eslint.Rule namespace. Waiting for better compatibility in
+        // https://github.com/typescript-eslint/typescript-eslint/tree/1765a178e456b152bd48192eb5db7e8541e2adf2/packages/experimental-utils#note
+        // Meanwhile, use a debugger to explore the AST node.
+        Program(_node) {
+            if (!isTestFile(context.getFilename())) {
+                return;
+            }
+            importCache = new import_cache_1.ImportCache();
+            importsFixed = false;
+        },
+        ImportDeclaration(node) {
+            if (!isTestFile(context.getFilename())) {
+                return;
+            }
+            if (node.source.value === '@aws-cdk/core') {
+                node.specifiers.forEach((s) => {
+                    if (s.type === 'ImportSpecifier' && BANNED_TYPES.includes(s.imported.name)) {
+                        // named import
+                        importCache.record({
+                            fileName: context.getFilename(),
+                            typeName: s.imported.name,
+                            importNode: node,
+                            localName: s.local.name,
+                        });
+                    }
+                    else if (s.type === 'ImportNamespaceSpecifier') {
+                        // barrel import
+                        BANNED_TYPES.forEach(typeName => {
+                            importCache.record({
+                                fileName: context.getFilename(),
+                                typeName,
+                                importNode: node,
+                                localName: `${s.local.name}.${typeName}`,
+                            });
+                        });
+                    }
+                });
+            }
+        },
+        Identifier(node) {
+            var _a;
+            if (!isTestFile(context.getFilename())) {
+                return;
+            }
+            // Only apply rule to bindings (variables and function parameters)
+            const typeAnnotation = (_a = node.typeAnnotation) === null || _a === void 0 ? void 0 : _a.typeAnnotation;
+            if (!typeAnnotation) {
+                return;
+            }
+            const type = typeAnnotation.typeName;
+            if (!type) {
+                return;
+            }
+            const message = 'Use Construct and IConstruct from the "constructs" module in variable declarations (not "@aws-cdk/core")';
+            if (type.type === 'TSQualifiedName') {
+                // barrel import
+                const qualifier = type.left.name;
+                const typename = type.right.name;
+                const importNode = findImportNode(`${qualifier}.${typename}`);
+                if (!importNode) {
+                    return;
+                }
+                context.report({
+                    node,
+                    message,
+                    fix: (fixer) => {
+                        const fixes = [];
+                        if (!importsFixed) {
+                            fixes.push(fixer.insertTextAfter(importNode, "\nimport * as constructs from 'constructs';"));
+                            importsFixed = true;
+                        }
+                        fixes.push(fixer.replaceTextRange(typeAnnotation.range, `constructs.${typename}`));
+                        return fixes;
+                    },
+                });
+            }
+            else if (type.type === 'Identifier') {
+                // named imports
+                const importNode = findImportNode(type.name);
+                if (!importNode) {
+                    return;
+                }
+                context.report({
+                    node,
+                    message,
+                    fix: (fixer) => {
+                        const fixes = [];
+                        if (!importsFixed) {
+                            const typesToImport = BANNED_TYPES.map(typeName => {
+                                const val = importCache.find({ fileName: context.getFilename(), typeName });
+                                if (!val) {
+                                    return undefined;
+                                }
+                                if (typeName === val.localName) {
+                                    return typeName;
+                                }
+                                return `${typeName} as ${val.localName}`;
+                            }).filter(x => x !== undefined);
+                            fixes.push(fixer.insertTextAfter(importNode, `\nimport { ${typesToImport.join(', ')} } from 'constructs';`));
+                            const specifiers = importNode.specifiers;
+                            if (specifiers.length === typesToImport.length) {
+                                fixes.push(fixer.removeRange(importNode.range));
+                            }
+                            else {
+                                for (let i = 0; i < specifiers.length; i++) {
+                                    const s = specifiers[i];
+                                    if (typesToImport.includes(s.imported.name)) {
+                                        if (i === specifiers.length - 1) {
+                                            fixes.push(fixer.removeRange([s.range[0] - 2, s.range[1]])); // include the leading comma
+                                        }
+                                        else {
+                                            fixes.push(fixer.removeRange([s.range[0], s.range[1] + 2])); // include the trailing comma
+                                        }
+                                    }
+                                }
+                            }
+                            importsFixed = true;
+                        }
+                        return fixes;
+                    },
+                });
+            }
+            else {
+                return;
+            }
+            function findImportNode(locaName) {
+                return BANNED_TYPES.map(typeName => {
+                    const val = importCache.find({ fileName: context.getFilename(), typeName });
+                    if (val && val.localName === locaName) {
+                        return val.importNode;
+                    }
+                    return undefined;
+                }).find(x => x !== undefined);
+            }
+        },
+    };
+}
+function isTestFile(filename) {
+    return new RegExp(/\/test\//).test(filename);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-core-construct.js","sourceRoot":"","sources":["../../src/rules/no-core-construct.ts"],"names":[],"mappings":"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","sourcesContent":["import { Rule } from 'eslint';\nimport { ImportCache, Node } from '../private/import-cache';\n\nlet importCache: ImportCache;\nlet importsFixed: boolean;\n\nconst BANNED_TYPES = ['IConstruct', 'Construct'];\n\nexport const meta = {\n  fixable: true,\n};\n\nexport function create(context: Rule.RuleContext): Rule.NodeListener {\n  return {\n\n    // `node` is a type from @typescript-eslint/typescript-estree, but using 'any' for now\n    // since it's incompatible with eslint.Rule namespace. Waiting for better compatibility in\n    // https://github.com/typescript-eslint/typescript-eslint/tree/1765a178e456b152bd48192eb5db7e8541e2adf2/packages/experimental-utils#note\n    // Meanwhile, use a debugger to explore the AST node.\n\n    Program(_node: any) {\n      if (!isTestFile(context.getFilename())) {\n        return;\n      }\n      importCache = new ImportCache();\n      importsFixed = false;\n    },\n\n    ImportDeclaration(node: any) {\n      if (!isTestFile(context.getFilename())) {\n        return;\n      }\n      if (node.source.value === '@aws-cdk/core') {\n        node.specifiers.forEach((s: any) => {\n          if (s.type === 'ImportSpecifier' && BANNED_TYPES.includes(s.imported.name)) {\n            // named import\n            importCache.record({\n              fileName: context.getFilename(),\n              typeName: s.imported.name,\n              importNode: node,\n              localName: s.local.name,\n            });\n          } else if (s.type === 'ImportNamespaceSpecifier') {\n            // barrel import\n            BANNED_TYPES.forEach(typeName => {\n              importCache.record({\n                fileName: context.getFilename(),\n                typeName,\n                importNode: node,\n                localName: `${s.local.name}.${typeName}`,\n              });\n            });\n          }\n        });\n      }\n    },\n\n    Identifier(node: any) {\n      if (!isTestFile(context.getFilename())) {\n        return;\n      }\n      // Only apply rule to bindings (variables and function parameters)\n      const typeAnnotation = node.typeAnnotation?.typeAnnotation;\n      if (!typeAnnotation) {\n        return;\n      }\n      const type = typeAnnotation.typeName;\n      if (!type) { return; }\n\n      const message = 'Use Construct and IConstruct from the \"constructs\" module in variable declarations (not \"@aws-cdk/core\")';\n\n      if (type.type === 'TSQualifiedName') {\n        // barrel import\n        const qualifier = type.left.name;\n        const typename = type.right.name;\n        const importNode = findImportNode(`${qualifier}.${typename}`);\n        if (!importNode) {\n          return;\n        }\n        context.report({\n          node,\n          message,\n          fix: (fixer: Rule.RuleFixer) => {\n            const fixes: Rule.Fix[] = [];\n            if (!importsFixed) {\n              fixes.push(fixer.insertTextAfter(importNode, \"\\nimport * as constructs from 'constructs';\"));\n              importsFixed = true;\n            }\n            fixes.push(fixer.replaceTextRange(typeAnnotation.range, `constructs.${typename}`));\n            return fixes;\n          },\n        });\n      } else if (type.type === 'Identifier') {\n        // named imports\n        const importNode = findImportNode(type.name);\n        if (!importNode) {\n          return;\n        }\n        context.report({\n          node,\n          message,\n          fix: (fixer: Rule.RuleFixer) => {\n            const fixes: Rule.Fix[] = [];\n            if (!importsFixed) {\n              const typesToImport = BANNED_TYPES.map(typeName => {\n                const val = importCache.find({ fileName: context.getFilename(), typeName });\n                if (!val) { return undefined; }\n                if (typeName === val.localName) { return typeName; }\n                return `${typeName} as ${val.localName}`;\n              }).filter(x => x !== undefined);\n              fixes.push(fixer.insertTextAfter(importNode, `\\nimport { ${typesToImport.join(', ')} } from 'constructs';`));\n\n              const specifiers = importNode.specifiers;\n              if (specifiers.length === typesToImport.length) {\n                fixes.push(fixer.removeRange(importNode.range));\n              } else {\n                for (let i = 0; i < specifiers.length; i++) {\n                  const s = specifiers[i];\n                  if (typesToImport.includes(s.imported.name)) {\n                    if (i === specifiers.length - 1) {\n                      fixes.push(fixer.removeRange([s.range[0] - 2, s.range[1]])); // include the leading comma\n                    } else {\n                      fixes.push(fixer.removeRange([s.range[0], s.range[1] + 2])); // include the trailing comma\n                    }\n                  }\n                }\n              }\n              importsFixed = true;\n            }\n            return fixes;\n          },\n        });\n      } else {\n        return;\n      }\n\n      function findImportNode(locaName: string): Node | undefined {\n        return BANNED_TYPES.map(typeName => {\n          const val = importCache.find({ fileName: context.getFilename(), typeName });\n          if (val && val.localName === locaName) {\n            return val.importNode;\n          }\n          return undefined;\n        }).find(x => x !== undefined);\n      }\n    },\n  };\n}\n\nfunction isTestFile(filename: string) {\n  return new RegExp(/\\/test\\//).test(filename);\n}"]}

package/lib/rules/no-invalid-path.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from 'eslint';
+export declare function create(context: Rule.RuleContext): Rule.NodeListener;

package/lib/rules/no-invalid-path.js

@@ -0,0 +1,102 @@
+"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.create = create;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function isPathJoinFuncCall(node) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    return (((_b = (_a = node.callee) === null || _a === void 0 ? void 0 : _a.property) === null || _b === void 0 ? void 0 : _b.name) === 'join' &&
+        (((_f = (_e = (_d = (_c = node.parent) === null || _c === void 0 ? void 0 : _c.expression) === null || _d === void 0 ? void 0 : _d.callee) === null || _e === void 0 ? void 0 : _e.object) === null || _f === void 0 ? void 0 : _f.name) === 'path' ||
+            ((_h = (_g = node.parent) === null || _g === void 0 ? void 0 : _g.arguments) === null || _h === void 0 ? void 0 : _h.some((a) => { var _a, _b; return ((_b = (_a = a.callee) === null || _a === void 0 ? void 0 : _a.object) === null || _b === void 0 ? void 0 : _b.name) === 'path'; }))));
+}
+function noArgumentVariables(node) {
+    // Outside of the first argument, all arguments should be strings
+    const components = node.arguments.slice(1);
+    return components.every((a) => a.value !== undefined);
+}
+function hasSlashes(args) {
+    return args.some((a) => a.includes('/'));
+}
+function firstArgIsDirname(node) {
+    return node.arguments[0].name && node.arguments[0].name === '__dirname';
+}
+function argumentList(node) {
+    // Already confirmed that first argument is '__dirname', so can safely remove it
+    const args = node.arguments.slice(1).map((a) => { return a.value; });
+    return args;
+}
+function recreatePath(args) {
+    return `path.join(__dirname, '${args.join('\', \'')}')`;
+}
+function create(context) {
+    return {
+        CallExpression(node) {
+            if (isPathJoinFuncCall(node)) {
+                if (node.arguments.length === 0) {
+                    // ERROR: this is 'path.join()'
+                    context.report({ node, message: '\'path.join()\' is not a valid path. You must specify arguments into the function.' });
+                    return;
+                }
+                if (!noArgumentVariables(node)) {
+                    // WARNING: unexpected non-string in the argument list. This happens if part of the argument list is a variable, i.e. `path.join(__dirname, myPath)`.
+                    // We may be able to do something about this, but we currently are just going to let it pass.
+                    return;
+                }
+                // We currently do not lint any path.join without '__dirname' as the first argument
+                if (!firstArgIsDirname(node)) {
+                    return;
+                }
+                const args = argumentList(node);
+                if (hasSlashes(args)) {
+                    // ERROR: This path looks like 'path.join(__dirname, 'a/b')' and should be changed to 'path.join(__dirname, 'a', 'b')'
+                    context.report({ node, message: `${recreatePath(args)} is not a valid path. It has '/' in the arguments which is not allowed. Each directory should be its own separate argument.` });
+                    return;
+                }
+                const firstDownDir = args.findIndex((p) => p !== '..');
+                // Confirm path does not have any unnecessary '..' paths
+                // This allows us to validate subsequent checks
+                if (firstDownDir > 0 && args.some((p, i) => p === '..' && i > firstDownDir)) {
+                    // ERROR: This path oscillates between up and down commands
+                    context.report({ node, message: `${recreatePath(args)} is not a valid path. It goes backwards and forwards and backwards again, and can be simplified.` });
+                    return;
+                }
+                // Exclude the case where there are no '..' at all in the path -- those are never invalid
+                const currentFile = context.getFilename();
+                if (firstDownDir > 0) {
+                    for (let i = 0; i < firstDownDir; i++) {
+                        const pjFile = path.join(...[path.dirname(currentFile), ...args.slice(0, i), 'package.json']);
+                        if (fs.existsSync(pjFile)) {
+                            // ERROR: this path will end up going out of the package.json directory
+                            context.report({ node, message: `${recreatePath(args)} is not a valid path. It goes beyond the parent library's package.json file so the file it points to will not be available after the library is packaged.` });
+                            return;
+                        }
+                    }
+                }
+            }
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-invalid-path.js","sourceRoot":"","sources":["../../src/rules/no-invalid-path.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { Rule } from 'eslint';\n\nfunction isPathJoinFuncCall(node: any): boolean {\n  return (\n    node.callee?.property?.name === 'join' &&\n    (node.parent?.expression?.callee?.object?.name === 'path' ||\n    node.parent?.arguments?.some((a: any) => a.callee?.object?.name === 'path'))\n  );\n}\n\nfunction noArgumentVariables(node: any): boolean {\n  // Outside of the first argument, all arguments should be strings\n  const components = node.arguments.slice(1);\n  return components.every((a: any) => a.value !== undefined);\n}\n\nfunction hasSlashes(args: string[]): boolean {\n  return args.some((a) => a.includes('/'));\n}\n\nfunction firstArgIsDirname(node: any): boolean {\n  return node.arguments[0].name && node.arguments[0].name === '__dirname';\n}\n\nfunction argumentList(node: any): string[] {\n  // Already confirmed that first argument is '__dirname', so can safely remove it\n  const args: string[] = node.arguments.slice(1).map((a: any) => { return a.value; });\n  return args;\n}\n\nfunction recreatePath(args: string[]): string {\n  return `path.join(__dirname, '${args.join('\\', \\'')}')`;\n}\n\nexport function create(context: Rule.RuleContext): Rule.NodeListener {\n  return {\n    CallExpression(node: any) {\n      if (isPathJoinFuncCall(node)) {\n        if (node.arguments.length === 0) {\n          // ERROR: this is 'path.join()'\n          context.report({ node, message: '\\'path.join()\\' is not a valid path. You must specify arguments into the function.' });\n          return;\n        }\n\n        if (!noArgumentVariables(node)) {\n          // WARNING: unexpected non-string in the argument list. This happens if part of the argument list is a variable, i.e. `path.join(__dirname, myPath)`.\n          // We may be able to do something about this, but we currently are just going to let it pass.\n          return;\n        }\n\n        // We currently do not lint any path.join without '__dirname' as the first argument\n        if (!firstArgIsDirname(node)) {\n          return;\n        }\n\n        const args = argumentList(node);\n\n        if (hasSlashes(args)) {\n          // ERROR: This path looks like 'path.join(__dirname, 'a/b')' and should be changed to 'path.join(__dirname, 'a', 'b')'\n          context.report({ node, message: `${recreatePath(args)} is not a valid path. It has '/' in the arguments which is not allowed. Each directory should be its own separate argument.` });\n          return;\n        }\n\n        const firstDownDir = args.findIndex((p) => p !== '..');\n\n        // Confirm path does not have any unnecessary '..' paths\n        // This allows us to validate subsequent checks\n        if (firstDownDir > 0 && args.some((p, i) => p === '..' && i > firstDownDir)) {\n          // ERROR: This path oscillates between up and down commands\n          context.report({ node, message: `${recreatePath(args)} is not a valid path. It goes backwards and forwards and backwards again, and can be simplified.` });\n          return;\n        }\n\n        // Exclude the case where there are no '..' at all in the path -- those are never invalid\n        const currentFile = context.getFilename();\n        if (firstDownDir > 0) {\n          for (let i = 0; i < firstDownDir; i++) {\n            const pjFile = path.join(...[path.dirname(currentFile), ...args.slice(0, i), 'package.json']);\n            if (fs.existsSync(pjFile)) {\n              // ERROR: this path will end up going out of the package.json directory\n              context.report({ node, message: `${recreatePath(args)} is not a valid path. It goes beyond the parent library's package.json file so the file it points to will not be available after the library is packaged.` });\n              return;\n            }\n          }\n        }\n      }\n    },\n  };\n}\n"]}

package/lib/rules/no-literal-partition.d.ts

@@ -0,0 +1,7 @@
+import { Rule } from 'eslint';
+export declare const meta: {
+    messages: {
+        hardcodedArn: string;
+    };
+};
+export declare function create(context: Rule.RuleContext): Rule.NodeListener;

package/lib/rules/no-literal-partition.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meta = void 0;
+exports.create = create;
+const is_prod_file_1 = require("../private/is-prod-file");
+exports.meta = {
+    messages: {
+        hardcodedArn: 'There are more partitions than just \'aws\'. Silence this message if you are sure this is safe, or switch to using \'Aws.PARTITION\'',
+    },
+};
+function create(context) {
+    return {
+        // `node` is a type from @typescript-eslint/typescript-estree, but using 'any' for now
+        // since it's incompatible with eslint.Rule namespace. Waiting for better compatibility in
+        // https://github.com/typescript-eslint/typescript-eslint/tree/1765a178e456b152bd48192eb5db7e8541e2adf2/packages/experimental-utils#note
+        // Meanwhile, use a debugger to explore the AST node.
+        Literal(node) {
+            if (!(0, is_prod_file_1.isProdFile)(context.getFilename())) {
+                return;
+            }
+            if (typeof node.value === 'string' && node.value.includes('arn:aws:')) {
+                context.report({ node, messageId: 'hardcodedArn' });
+            }
+        },
+        TemplateLiteral(node) {
+            if (!(0, is_prod_file_1.isProdFile)(context.getFilename())) {
+                return;
+            }
+            for (const quasi of node.quasis) {
+                const value = quasi.value.cooked;
+                if (typeof value === 'string' && value.includes('arn:aws:')) {
+                    context.report({ node: quasi, messageId: 'hardcodedArn' });
+                }
+            }
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/rules/promiseall-no-unbounded-parallelism.d.ts

@@ -0,0 +1,24 @@
+import { Rule } from 'eslint';
+/**
+ * Get the programmer to acknowledge that `Promise.all()` is potentially dangerous.
+ *
+ * Since JavaScript is single-threaded, `Promise.all()` will only ever be used for
+ * I/O-bound tasks. However, I/O-parallelism isn't free either. Every async I/O-performing
+ * task launched will consume some FDs, and their amount is limited. If the amount
+ * of promises launched is a function of the input the program runs on, the system
+ * FDs might be exhausted. Some concurrency limit must be introduced.
+ *
+ * This linter rule exists to remind the programmer of that fact. It triggers
+ * on every `Promise.all()` invocation and cannot be resolved; the only solution
+ * is to think about it, and then silence this rule as proof that you thought about it.
+ *
+ * In summary, it's fine if:
+ *
+ * - The arguments to `Promise.all()` is a fixed set of promises; OR
+ * - The arguments to `Promise.all()` is throttled by a mechanism like 'p-limit' or
+ *   similar.
+ *
+ * (This check is currently only in the CDK repo; it can benefit all TypeScript repos,
+ * we should introduce and publish a global lint rules package).
+ */
+export declare function create(context: Rule.RuleContext): Rule.NodeListener;

package/lib/rules/promiseall-no-unbounded-parallelism.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+const match_ast_1 = require("../private/match-ast");
+const type_checkers_1 = require("../private/type-checkers");
+/**
+ * Get the programmer to acknowledge that `Promise.all()` is potentially dangerous.
+ *
+ * Since JavaScript is single-threaded, `Promise.all()` will only ever be used for
+ * I/O-bound tasks. However, I/O-parallelism isn't free either. Every async I/O-performing
+ * task launched will consume some FDs, and their amount is limited. If the amount
+ * of promises launched is a function of the input the program runs on, the system
+ * FDs might be exhausted. Some concurrency limit must be introduced.
+ *
+ * This linter rule exists to remind the programmer of that fact. It triggers
+ * on every `Promise.all()` invocation and cannot be resolved; the only solution
+ * is to think about it, and then silence this rule as proof that you thought about it.
+ *
+ * In summary, it's fine if:
+ *
+ * - The arguments to `Promise.all()` is a fixed set of promises; OR
+ * - The arguments to `Promise.all()` is throttled by a mechanism like 'p-limit' or
+ *   similar.
+ *
+ * (This check is currently only in the CDK repo; it can benefit all TypeScript repos,
+ * we should introduce and publish a global lint rules package).
+ */
+function create(context) {
+    return {
+        CallExpression: node => {
+            if ((0, match_ast_1.match)(node.callee, (0, type_checkers_1.matchMemberExpression)({
+                object: (0, type_checkers_1.matchIdentifier)('Promise'),
+                property: (0, type_checkers_1.matchIdentifier)('all'),
+            }))) {
+                context.report({
+                    message: 'Ensure the number of awaited promises does not depend on program input, or their parallelism is limited using something like \'p-limit\' or similar. Acknowledge this message using \'// eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\'',
+                    node,
+                });
+            }
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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