eslint-plugin-skuba 1.0.3-replace-global-vars-20251121010036 → 1.0.4-node-24-20251215224735

package/lib/index.cjs

@@ -0,0 +1,370 @@
+let __typescript_eslint_utils = require("@typescript-eslint/utils");
+
+//#region src/rules/no-sync-in-promise-iterable.ts
+/**
+* Whether a TypeScript type is a Promise-like "thenable".
+*/
+const isThenableType = (type, checker) => {
+	if (type.symbol?.name === "Promise") return true;
+	const thenSymbol = type.getProperty("then");
+	if (thenSymbol?.valueDeclaration) {
+		if (checker.getTypeOfSymbolAtLocation(thenSymbol, thenSymbol.valueDeclaration).getCallSignatures().length) return true;
+	}
+	if (type.isUnion()) return type.types.every((t) => isThenableType(t, checker));
+	return false;
+};
+/**
+* Whether a node represents a Promise-like "thenable".
+*/
+const isThenableNode = (node, esTreeNodeToTSNodeMap, checker) => {
+	const tsNode = esTreeNodeToTSNodeMap.get(node);
+	return isThenableType(checker.getTypeAtLocation(tsNode), checker);
+};
+const isIterableType = (type, checker) => {
+	if (checker.isArrayLikeType(type)) return true;
+	return type.getProperties().some((property) => property.name.startsWith("__@iterator"));
+};
+const PROMISE_INSTANCE_METHODS = new Set([
+	"catch",
+	"then",
+	"finally"
+]);
+const isChainedPromise = (node, esTreeNodeToTSNodeMap, checker) => {
+	if (!(node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.MemberExpression && node.callee.property.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && PROMISE_INSTANCE_METHODS.has(node.callee.property.name))) return false;
+	const parent = esTreeNodeToTSNodeMap.get(node.callee.object);
+	return isThenableType(checker.getTypeAtLocation(parent), checker);
+};
+/**
+* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
+*/
+const SAFE_ISH_CONSTRUCTORS = new Set([
+	"AggregateError",
+	"AsyncDisposableStack",
+	"Boolean",
+	"Date",
+	"DisposableStack",
+	"Error",
+	"EvalError",
+	"FinalizationRegistry",
+	"Map",
+	"Number",
+	"Object",
+	"Promise",
+	"Proxy",
+	"RangeError",
+	"ReferenceError",
+	"Set",
+	"SharedArrayBuffer",
+	"String",
+	"SuppressedError",
+	"Symbol",
+	"SyntaxError",
+	"TypeError",
+	"URIError",
+	"WeakMap",
+	"WeakRef",
+	"WeakSet"
+]);
+const SAFE_ISH_FUNCTIONS = new Set([
+	"Boolean",
+	"isFinite",
+	"isNaN",
+	"Number",
+	"parseFloat",
+	"parseInt",
+	"String",
+	"Symbol"
+]);
+const SAFE_ISH_STATIC_METHODS = {
+	Array: new Set([
+		"from",
+		"isArray",
+		"of"
+	]),
+	Date: new Set([
+		"now",
+		"parse",
+		"UTC"
+	]),
+	Iterator: new Set(["from"]),
+	Number: new Set([
+		"isFinite",
+		"isInteger",
+		"isNaN",
+		"isSafeInteger",
+		"parseFloat",
+		"parseInt"
+	]),
+	Object: new Set([
+		"entries",
+		"fromEntries",
+		"groupBy",
+		"hasOwn",
+		"is",
+		"keys",
+		"values"
+	]),
+	Promise: new Set([
+		"reject",
+		"resolve",
+		"try",
+		"withResolvers"
+	])
+};
+const SAFE_ISH_INSTANCE_METHODS = new Set([
+	"apply",
+	"bind",
+	"call",
+	"toLocaleString",
+	"toString"
+]);
+const isArrayFromAsync = (node) => node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.MemberExpression && node.callee.object.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && node.callee.property.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && node.callee.object.name === "Array" && node.callee.property.name === "fromAsync";
+const isPromiseTry = (node) => node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.MemberExpression && node.callee.object.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && node.callee.object.name === "Promise" && node.callee.property.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && node.callee.property.name === "try";
+/**
+* Whether a call expression represents a safe-ish built-in.
+*
+* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
+*/
+const isSafeIshBuiltIn = (node) => {
+	if (node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier) return SAFE_ISH_FUNCTIONS.has(node.callee.name);
+	if (node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.MemberExpression) {
+		const { object, property } = node.callee;
+		if (object.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && property.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier) return SAFE_ISH_STATIC_METHODS[object.name]?.has(property.name) ?? SAFE_ISH_INSTANCE_METHODS.has(property.name);
+	}
+	return false;
+};
+const SAFE_ISH_ITERABLE_INSTANCE_METHODS = new Set([
+	"concat",
+	"copyWithin",
+	"difference",
+	"drop",
+	"entries",
+	"every",
+	"fill",
+	"filter",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"flat",
+	"flatMap",
+	"has",
+	"includes",
+	"indexOf",
+	"intersection",
+	"keys",
+	"lastIndexOf",
+	"map",
+	"reduce",
+	"reduceRight",
+	"reverse",
+	"slice",
+	"some",
+	"splice",
+	"symmetricDifference",
+	"toArray",
+	"toReversed",
+	"toSorted",
+	"toSpliced",
+	"union",
+	"values",
+	"with"
+]);
+/**
+* Whether a call expression represents a method on an iterable object that is
+* unlikely to internally throw a synchronous error.
+*/
+const isSafeIshIterableMethod = (node, esTreeNodeToTSNodeMap, checker) => {
+	if (!(node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.MemberExpression && node.callee.property.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && SAFE_ISH_ITERABLE_INSTANCE_METHODS.has(node.callee.property.name))) return false;
+	const tsNode = esTreeNodeToTSNodeMap.get(node.callee.object);
+	return isIterableType(checker.getTypeAtLocation(tsNode), checker);
+};
+/**
+* Whether a call expression represents a safe-ish builder.
+*
+* This is currently overfitted to `knex`.
+*/
+const isSafeIshBuilder = (node) => {
+	if (node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.MemberExpression && node.callee.object.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.CallExpression) return isSafeIshBuilder(node.callee.object);
+	if (node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && node.callee.name === "knex" || node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.MemberExpression && node.callee.object.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && node.callee.object.name === "knex") return true;
+	return false;
+};
+/**
+* The nodes traversable from the current AST position containing logic with a
+* reasonable chance of throwing a synchronous error.
+*/
+const possibleNodesWithSyncError = (node, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls) => {
+	switch (node.type) {
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.ArrayExpression: return node.elements.flatMap((arg) => arg ? possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls) : []);
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression:
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.FunctionExpression:
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.FunctionDeclaration:
+			if (calls < 1) return [];
+			if (node.async) return [];
+			if (node.body.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.BlockStatement) return [node.parent];
+			return possibleNodesWithSyncError(node.body, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls - 1);
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.AssignmentExpression: return possibleNodesWithSyncError(node.right, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls);
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.BinaryExpression:
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.LogicalExpression: return [node.left, node.right].flatMap((arg) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls));
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.CallExpression: {
+			if (isSafeIshBuilder(node)) return [];
+			if (isPromiseTry(node)) return node.arguments.flatMap((arg, index) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, index === 0 ? calls : calls + 1));
+			if (isArrayFromAsync(node)) return node.arguments.flatMap((arg, index) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, index === 1 ? calls : calls + 1));
+			if (isSafeIshBuiltIn(node)) return node.arguments.flatMap((arg) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls + 1));
+			const collectCalleeArgumentErrors = (callee) => {
+				if (callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.CallExpression) {
+					const nestedErrors = collectCalleeArgumentErrors(callee.callee);
+					const argErrors = callee.arguments.flatMap((arg) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls + 1));
+					return [...nestedErrors, ...argErrors];
+				}
+				return [];
+			};
+			const expression = node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier ? findExpression(node.callee, sourceCode, visited) : node.callee;
+			if (expression?.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression || expression?.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.FunctionExpression) return [expression, ...node.arguments].flatMap((arg) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls + 1));
+			const calleeErrors = collectCalleeArgumentErrors(node.callee);
+			if (isChainedPromise(node, esTreeNodeToTSNodeMap, checker)) return [...calleeErrors, ...node.arguments.flatMap((arg) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls))];
+			if (isSafeIshIterableMethod(node, esTreeNodeToTSNodeMap, checker) || isThenableNode(node, esTreeNodeToTSNodeMap, checker)) return [...calleeErrors, ...node.arguments.flatMap((arg) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls + 1))];
+			if (calleeErrors.length) return calleeErrors;
+			return [node];
+		}
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.ChainExpression: return possibleNodesWithSyncError(node.expression, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls);
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.ConditionalExpression: return [
+			node.test,
+			node.consequent,
+			node.alternate
+		].flatMap((arg) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls));
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier: return [];
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Literal: return [];
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.MemberExpression: return possibleNodesWithSyncError(node.object, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls);
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.NewExpression:
+			if (node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && node.callee.name === "Promise") return node.arguments.flatMap((arg, index) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, index === 0 ? calls : calls + 1));
+			if (node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && SAFE_ISH_CONSTRUCTORS.has(node.callee.name)) return node.arguments.flatMap((arg) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls + 1));
+			return [node];
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.SequenceExpression: return node.expressions.flatMap((arg) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls));
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.SpreadElement: return possibleNodesWithSyncError(node.argument, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls);
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.TaggedTemplateExpression: return [node];
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.TemplateLiteral: return node.expressions.flatMap((arg) => possibleNodesWithSyncError(arg, esTreeNodeToTSNodeMap, checker, sourceCode, visited, calls));
+	}
+	return [];
+};
+const getSourceCodeExcerpt = (node, sourceCode) => {
+	const text = sourceCode.getText(node);
+	const lines = text.split("\n");
+	return lines.length <= 2 ? text : `${lines[0]?.trimEnd()}...${lines[lines.length - 1]?.trimStart()}`;
+};
+const checkIterableForSyncErrors = (elements, method, context, esTreeNodeToTSNodeMap, checker) => {
+	for (const { element, reference } of elements) {
+		const nodes = possibleNodesWithSyncError(element, esTreeNodeToTSNodeMap, checker, context.sourceCode, /* @__PURE__ */ new Set(), 0);
+		for (const node of nodes) {
+			const root = reference ?? element;
+			const value = getSourceCodeExcerpt(root, context.sourceCode);
+			if (root.loc.start.column === node.loc.start.column && root.loc.start.line === node.loc.start.line) context.report({
+				node,
+				messageId: "mayThrowSyncError",
+				data: {
+					value,
+					method
+				}
+			});
+			else context.report({
+				node,
+				messageId: "mayLeadToSyncError",
+				data: {
+					value,
+					method,
+					underlying: getSourceCodeExcerpt(node, context.sourceCode),
+					line: node.loc.start.line.toString(),
+					column: node.loc.start.column.toString()
+				}
+			});
+		}
+	}
+};
+const findExpression = (node, sourceCode, visited) => {
+	let currentScope = sourceCode.getScope(node);
+	do {
+		const variable = currentScope.set.get(node.name);
+		const definition = variable?.defs[0];
+		if (!definition) continue;
+		if (visited.has(variable.name)) return;
+		visited.add(variable.name);
+		if (definition.node.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.VariableDeclarator && definition.node.init) return definition.node.init;
+	} while (currentScope = currentScope.upper);
+};
+const resolveArrayElements = (node, sourceCode, visited = /* @__PURE__ */ new Set(), reference) => {
+	switch (node.type) {
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.ArrayExpression: return node.elements.flatMap((element, index) => {
+			if (!element) return [];
+			if (element.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.SpreadElement) return resolveArrayElements(element.argument, sourceCode, visited, reference ?? element);
+			if (index === 0) return [];
+			return {
+				element,
+				reference
+			};
+		});
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.CallExpression: return [{
+			element: node,
+			reference
+		}];
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier: {
+			const expression = findExpression(node, sourceCode, visited);
+			if (!expression) return [];
+			return resolveArrayElements(expression, sourceCode, visited, reference ?? node);
+		}
+		case __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.SpreadElement: return resolveArrayElements(node.argument, sourceCode, visited, reference ?? node);
+	}
+	return [];
+};
+const createRule = __typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/seek-oss/skuba/tree/main/docs/eslint-plugin/${name}.md`);
+var no_sync_in_promise_iterable_default = createRule({
+	defaultOptions: [],
+	name: "no-sync-in-promise-iterable",
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Heuristically flags synchronous logic in the iterable argument of static Promise methods that could leave preceding promises dangling",
+			recommended: true,
+			requiresTypeChecking: true
+		},
+		schema: [],
+		messages: {
+			mayLeadToSyncError: "{{value}} leads to {{underlying}} at {{line}}:{{column}} which may synchronously throw an error and leave preceding promises dangling. Evaluate synchronous expressions outside of the iterable argument to Promise.{{method}}, or safely wrap with the async keyword, Promise.try(), or Promise.resolve().then().",
+			mayThrowSyncError: "{{value}} may synchronously throw an error and leave preceding promises dangling. Evaluate synchronous expressions outside of the iterable argument to Promise.{{method}}, or safely wrap with the async keyword, Promise.try(), or Promise.resolve().then()."
+		}
+	},
+	create: (context) => {
+		const { esTreeNodeToTSNodeMap, program } = __typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		const checker = program.getTypeChecker();
+		return { CallExpression: (node) => {
+			if (!(node.callee.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.MemberExpression && node.callee.object.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && node.callee.object.name === "Promise" && node.callee.property.type === __typescript_eslint_utils.TSESTree.AST_NODE_TYPES.Identifier && [
+				"all",
+				"allSettled",
+				"any",
+				"race"
+			].includes(node.callee.property.name))) return;
+			const method = node.callee.property.name;
+			const iterableArg = node.arguments[0];
+			if (!iterableArg) return;
+			checkIterableForSyncErrors(resolveArrayElements(iterableArg, context.sourceCode), method, context, esTreeNodeToTSNodeMap, checker);
+		} };
+	}
+});
+
+//#endregion
+//#region src/index.ts
+const skuba = {
+	meta: {
+		name: "skuba",
+		version: "1.0.0"
+	},
+	rules: { "no-sync-in-promise-iterable": no_sync_in_promise_iterable_default },
+	configs: {}
+};
+skuba.configs = { recommended: [{
+	plugins: { skuba },
+	rules: { "skuba/no-sync-in-promise-iterable": "warn" }
+}] };
+var src_default = skuba;
+
+//#endregion
+module.exports = src_default;