@harness-engineering/eslint-plugin 0.3.1 → 0.4.0

package/dist/index.d.ts

@@ -28,6 +28,9 @@ declare const rules: {
     'no-sync-io-in-async': _typescript_eslint_utils_ts_eslint.RuleModule<"syncIoInAsync", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
         name: string;
     };
+    'no-undefined-optional-assignment': _typescript_eslint_utils_ts_eslint.RuleModule<"undefinedOptionalAssignment", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+        name: string;
+    };
     'no-unbounded-array-chains': _typescript_eslint_utils_ts_eslint.RuleModule<"unboundedArrayChain", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
         name: string;
     };
@@ -75,6 +78,9 @@ declare const plugin: {
         'no-sync-io-in-async': _typescript_eslint_utils_ts_eslint.RuleModule<"syncIoInAsync", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
             name: string;
         };
+        'no-undefined-optional-assignment': _typescript_eslint_utils_ts_eslint.RuleModule<"undefinedOptionalAssignment", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+            name: string;
+        };
         'no-unbounded-array-chains': _typescript_eslint_utils_ts_eslint.RuleModule<"unboundedArrayChain", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
             name: string;
         };
@@ -166,6 +172,9 @@ declare const configs: {
                     'no-sync-io-in-async': _typescript_eslint_utils_ts_eslint.RuleModule<"syncIoInAsync", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
                         name: string;
                     };
+                    'no-undefined-optional-assignment': _typescript_eslint_utils_ts_eslint.RuleModule<"undefinedOptionalAssignment", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+                        name: string;
+                    };
                     'no-unbounded-array-chains': _typescript_eslint_utils_ts_eslint.RuleModule<"unboundedArrayChain", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
                         name: string;
                     };
@@ -232,6 +241,9 @@ declare const configs: {
                     'no-sync-io-in-async': _typescript_eslint_utils_ts_eslint.RuleModule<"syncIoInAsync", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
                         name: string;
                     };
+                    'no-undefined-optional-assignment': _typescript_eslint_utils_ts_eslint.RuleModule<"undefinedOptionalAssignment", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+                        name: string;
+                    };
                     'no-unbounded-array-chains': _typescript_eslint_utils_ts_eslint.RuleModule<"unboundedArrayChain", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
                         name: string;
                     };

package/dist/index.js

@@ -1073,6 +1073,69 @@ var require_path_normalization_default = createRule12({
   }
 });
 
+// src/rules/no-undefined-optional-assignment.ts
+import { ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
+var createRule13 = ESLintUtils13.RuleCreator(
+  (name) => `https://github.com/harness-engineering/eslint-plugin/blob/main/docs/rules/${name}.md`
+);
+function unionIncludesUndefined(typeNode) {
+  return typeNode?.type === "TSUnionType" && typeNode.types.some((t) => t.type === "TSUndefinedKeyword");
+}
+function declaredType(identifier, scope) {
+  const ref = scope.references.find((r) => r.identifier === identifier);
+  const name = ref?.resolved?.defs[0]?.name;
+  if (name?.type !== "Identifier") return void 0;
+  return name.typeAnnotation?.typeAnnotation;
+}
+function checksDefined(expr, name) {
+  if (expr.type !== "BinaryExpression" || expr.operator !== "!==" && expr.operator !== "!=") {
+    return false;
+  }
+  const refsName = (n) => n.type === "Identifier" && n.name === name;
+  const isNullish = (n) => n.type === "Identifier" && n.name === "undefined" || n.type === "Literal" && n.value === null;
+  return refsName(expr.left) && isNullish(expr.right) || refsName(expr.right) && isNullish(expr.left);
+}
+function isGuarded(node, name) {
+  for (let cur = node.parent; cur; cur = cur.parent) {
+    if (cur.type === "LogicalExpression" && cur.operator === "&&" && checksDefined(cur.left, name)) {
+      return true;
+    }
+  }
+  return false;
+}
+var no_undefined_optional_assignment_default = createRule13({
+  name: "no-undefined-optional-assignment",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow assigning a possibly-undefined variable directly to an object property, which breaks `exactOptionalPropertyTypes`; use a conditional spread instead."
+    },
+    messages: {
+      undefinedOptionalAssignment: "Assigning possibly-undefined '{{name}}' directly to '{{field}}' breaks exactOptionalPropertyTypes. Use a conditional spread: ...({{name}} !== undefined && {{ '{' }} {{field}}: {{name}} {{ '}' }})."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Property(node) {
+        if (node.computed || node.value.type !== "Identifier") return;
+        if (node.key.type !== "Identifier" && node.key.type !== "Literal") return;
+        const value = node.value;
+        const scope = context.sourceCode.getScope(value);
+        if (!unionIncludesUndefined(declaredType(value, scope))) return;
+        if (isGuarded(node, value.name)) return;
+        const field = node.key.type === "Identifier" ? node.key.name : String(node.key.value);
+        context.report({
+          node: value,
+          messageId: "undefinedOptionalAssignment",
+          data: { name: value.name, field }
+        });
+      }
+    };
+  }
+});
+
 // src/rules/index.ts
 var rules = {
   "enforce-doc-exports": enforce_doc_exports_default,
@@ -1083,6 +1146,7 @@ var rules = {
   "no-nested-loops-in-critical": no_nested_loops_in_critical_default,
   "no-process-env-in-spawn": no_process_env_in_spawn_default,
   "no-sync-io-in-async": no_sync_io_in_async_default,
+  "no-undefined-optional-assignment": no_undefined_optional_assignment_default,
   "no-unbounded-array-chains": no_unbounded_array_chains_default,
   "no-unix-shell-command": no_unix_shell_command_default,
   "require-boundary-schema": require_boundary_schema_default,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-engineering/eslint-plugin",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "ESLint plugin for harness engineering architectural constraints",
   "type": "module",
   "main": "./dist/index.js",