eslint-plugin-ts-data-forge 0.1.0

package/src/rules/prefer-is-record-and-has-key.mts

@@ -0,0 +1,156 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useIsRecordAndHasKey';
+
+export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
+  {
+    meta: {
+      type: 'suggestion',
+      docs: {
+        description:
+          'Replace `Object.hasOwn(obj, key)` or `key in obj` with `isRecord(obj) && hasKey(obj, key)` from ts-data-forge',
+      },
+      fixable: 'code',
+      schema: [],
+      messages: {
+        useIsRecordAndHasKey:
+          'Replace `{{original}}` with `isRecord({{objName}}) && hasKey({{objName}}, {{keyName}})` from ts-data-forge.',
+      },
+    },
+
+    create: (context) => {
+      const sourceCode = context.sourceCode;
+
+      const program = sourceCode.ast;
+
+      const tsDataForgeImport = getTsDataForgeImport(program);
+
+      const mut_nodesToFix: {
+        node: TSESTree.CallExpression | TSESTree.BinaryExpression;
+        objExpression: TSESTree.Expression;
+        keyExpression: TSESTree.Expression;
+      }[] = [];
+
+      return {
+        // Handle Object.hasOwn(obj, key)
+        CallExpression: (node) => {
+          if (
+            node.callee.type !== AST_NODE_TYPES.MemberExpression ||
+            node.callee.object.type !== AST_NODE_TYPES.Identifier ||
+            node.callee.object.name !== 'Object' ||
+            node.callee.property.type !== AST_NODE_TYPES.Identifier ||
+            node.callee.property.name !== 'hasOwn'
+          ) {
+            return;
+          }
+
+          // Check arguments: Object.hasOwn(obj, key)
+          if (node.arguments.length !== 2) return;
+
+          const objArg = node.arguments[0];
+
+          const keyArg = node.arguments[1];
+
+          if (objArg === undefined || keyArg === undefined) return;
+
+          // Type guard: ensure arguments are Expressions (not SpreadElement)
+          if (
+            objArg.type === AST_NODE_TYPES.SpreadElement ||
+            keyArg.type === AST_NODE_TYPES.SpreadElement
+          ) {
+            return;
+          }
+
+          mut_nodesToFix.push({
+            node,
+            objExpression: objArg,
+            keyExpression: keyArg,
+          });
+        },
+
+        // Handle key in obj
+        BinaryExpression: (node) => {
+          if (node.operator !== 'in') return;
+
+          const keyExpression = node.left;
+
+          const objExpression = node.right;
+
+          // Type guard: ensure keyExpression is Expression (not PrivateIdentifier)
+          if (keyExpression.type === AST_NODE_TYPES.PrivateIdentifier) return;
+
+          mut_nodesToFix.push({
+            node,
+            objExpression,
+            keyExpression,
+          });
+        },
+
+        'Program:exit': () => {
+          const namedImports = getNamedImports(tsDataForgeImport);
+
+          const hasIsRecordImport = namedImports.includes('isRecord');
+
+          const hasHasKeyImport = namedImports.includes('hasKey');
+
+          for (const [
+            index,
+            { node, objExpression, keyExpression },
+          ] of mut_nodesToFix.entries()) {
+            const objText = sourceCode.getText(objExpression);
+
+            const keyText = sourceCode.getText(keyExpression);
+
+            const originalText = sourceCode.getText(node);
+
+            context.report({
+              node,
+              messageId: 'useIsRecordAndHasKey',
+              data: {
+                original: originalText,
+                objName: objText,
+                keyName: keyText,
+              },
+              fix: (fixer) => {
+                const replacement = `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`;
+
+                const mut_importsToAdd: string[] = [];
+
+                if (!hasIsRecordImport) {
+                  mut_importsToAdd.push('isRecord');
+                }
+
+                if (!hasHasKeyImport) {
+                  mut_importsToAdd.push('hasKey');
+                }
+
+                const importFixes =
+                  index === 0 && mut_importsToAdd.length > 0
+                    ? buildImportFixes(
+                        fixer,
+                        program,
+                        tsDataForgeImport,
+                        mut_importsToAdd,
+                      )
+                    : [];
+
+                return [...importFixes, fixer.replaceText(node, replacement)];
+              },
+            });
+          }
+        },
+      };
+    },
+    defaultOptions: [],
+  } as const;

package/src/rules/prefer-is-record-and-has-key.test.mts

@@ -0,0 +1,217 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferIsRecordAndHasKey } from './prefer-is-record-and-has-key.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-is-record-and-has-key', () => {
+  tester.run('prefer-is-record-and-has-key', preferIsRecordAndHasKey, {
+    valid: [
+      {
+        name: 'ignores other Object methods',
+        code: dedent`
+          const obj = { a: 1 };
+          const keys = Object.keys(obj);
+        `,
+      },
+      {
+        name: 'ignores hasOwn with wrong number of arguments',
+        code: dedent`
+          const obj = { a: 1 };
+          const ok = Object.hasOwn(obj);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'replaces Object.hasOwn(obj, key) with isRecord && hasKey',
+        code: dedent`
+          const obj = { a: 1 };
+          const ok = Object.hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const obj = { a: 1 };
+          const ok = (isRecord(obj) && hasKey(obj, 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'replaces key in obj with isRecord && hasKey',
+        code: dedent`
+          const obj = { a: 1 };
+          const ok = 'a' in obj;
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const obj = { a: 1 };
+          const ok = (isRecord(obj) && hasKey(obj, 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'works with variable key',
+        code: dedent`
+          const obj = { a: 1 };
+          const key = 'a';
+          const ok = Object.hasOwn(obj, key);
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const obj = { a: 1 };
+          const key = 'a';
+          const ok = (isRecord(obj) && hasKey(obj, key));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'works with in and variable key',
+        code: dedent`
+          const obj = { a: 1 };
+          const key = 'a';
+          const ok = key in obj;
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const obj = { a: 1 };
+          const key = 'a';
+          const ok = (isRecord(obj) && hasKey(obj, key));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'keeps existing isRecord import',
+        code: dedent`
+          import { isRecord } from 'ts-data-forge';
+
+          const obj = { a: 1 };
+          const ok = Object.hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-data-forge';
+          import { isRecord } from 'ts-data-forge';
+
+          const obj = { a: 1 };
+          const ok = (isRecord(obj) && hasKey(obj, 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'keeps existing hasKey import',
+        code: dedent`
+          import { hasKey } from 'ts-data-forge';
+
+          const obj = { a: 1 };
+          const ok = 'a' in obj;
+        `,
+        output: dedent`
+          import { isRecord } from 'ts-data-forge';
+          import { hasKey } from 'ts-data-forge';
+
+          const obj = { a: 1 };
+          const ok = (isRecord(obj) && hasKey(obj, 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'keeps both existing imports',
+        code: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+
+          const obj = { a: 1 };
+          const ok = Object.hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+
+          const obj = { a: 1 };
+          const ok = (isRecord(obj) && hasKey(obj, 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'replaces multiple checks',
+        code: dedent`
+          const obj = { a: 1 };
+          const ok1 = Object.hasOwn(obj, 'a');
+          const ok2 = 'b' in obj;
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const obj = { a: 1 };
+          const ok1 = (isRecord(obj) && hasKey(obj, 'a'));
+          const ok2 = (isRecord(obj) && hasKey(obj, 'b'));
+        `,
+        errors: [
+          { messageId: 'useIsRecordAndHasKey' },
+          { messageId: 'useIsRecordAndHasKey' },
+        ],
+      },
+      {
+        name: 'works with complex object expressions',
+        code: dedent`
+          const data = { nested: { value: 1 } };
+          const ok = Object.hasOwn(data.nested, 'value');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const data = { nested: { value: 1 } };
+          const ok = (isRecord(data.nested) && hasKey(data.nested, 'value'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'works with in and complex object expressions',
+        code: dedent`
+          const data = { nested: { value: 1 } };
+          const ok = 'value' in data.nested;
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const data = { nested: { value: 1 } };
+          const ok = (isRecord(data.nested) && hasKey(data.nested, 'value'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'correctly wraps negated Object.hasOwn with parentheses',
+        code: dedent`
+          const obj = { a: 1 };
+          const ok = !Object.hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const obj = { a: 1 };
+          const ok = !(isRecord(obj) && hasKey(obj, 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'correctly wraps negated key in obj with parentheses',
+        code: dedent`
+          const obj = { a: 1 };
+          const ok = !('a' in obj);
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const obj = { a: 1 };
+          const ok = !((isRecord(obj) && hasKey(obj, 'a')));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+    ],
+  });
+}, 20000);

package/src/rules/prefer-num-safe-parse-float.mts

@@ -0,0 +1,166 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useSafeParseFloat';
+
+/**
+ * Returns `true` when every constituent of `type` is string-like, i.e. the
+ * type is assignable to the `string` parameter of `Num.safeParseFloat`. A
+ * union such as `string | undefined` is rejected so the autofix never
+ * produces a type error.
+ */
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const isStringType = (type: ts.Type): boolean => {
+  const parts = type.isUnion() ? type.types : ([type] as const);
+
+  return (
+    parts.length > 0 &&
+    parts.every((t) => (t.flags & ts.TypeFlags.StringLike) !== 0)
+  );
+};
+
+/**
+ * Detects `parseFloat(x)`, `Number.parseFloat(x)`, and `Number(x)` (when x
+ * is typed as `string`) and replaces them with
+ * `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` (ts-data-forge).
+ *
+ * `Number(x)` is only flagged when x is purely a string type to avoid false
+ * positives for `Number(someBoolean)` or `Number(someNumber)` uses.
+ */
+export const preferNumSafeParseFloat: TSESLint.RuleModule<MessageIds, Options> =
+  {
+    meta: {
+      type: 'suggestion',
+      docs: {
+        description:
+          'Replace `parseFloat(x)`, `Number.parseFloat(x)`, or `Number(x)` (when x is a string) with `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` from ts-data-forge.',
+      },
+      fixable: 'code',
+      schema: [],
+      messages: {
+        useSafeParseFloat:
+          'Replace `{{original}}` with `Result.unwrapOkOr(Num.safeParseFloat({{argName}}), Number.NaN)` from ts-data-forge.',
+      },
+    },
+
+    create: (context) => {
+      const sourceCode = context.sourceCode;
+
+      const program = sourceCode.ast;
+
+      const tsDataForgeImport = getTsDataForgeImport(program);
+
+      const services = context.sourceCode.parserServices;
+
+      const mut_nodesToFix: {
+        node: TSESTree.CallExpression;
+        argExpression: TSESTree.Expression;
+      }[] = [];
+
+      return {
+        CallExpression: (node) => {
+          const { callee } = node;
+
+          // Match `parseFloat(...)` (global function).
+          const isGlobalParseFloat =
+            callee.type === AST_NODE_TYPES.Identifier &&
+            callee.name === 'parseFloat';
+
+          // Match `Number.parseFloat(...)`.
+          const isNumberParseFloat =
+            callee.type === AST_NODE_TYPES.MemberExpression &&
+            !callee.computed &&
+            callee.object.type === AST_NODE_TYPES.Identifier &&
+            callee.object.name === 'Number' &&
+            callee.property.type === AST_NODE_TYPES.Identifier &&
+            callee.property.name === 'parseFloat';
+
+          // Match `Number(...)` called as a function (not `new Number(...)`).
+          const isNumberCall =
+            callee.type === AST_NODE_TYPES.Identifier &&
+            callee.name === 'Number';
+
+          if (!isGlobalParseFloat && !isNumberParseFloat && !isNumberCall)
+            return;
+
+          const args = node.arguments;
+
+          const firstArg = args[0];
+
+          if (firstArg === undefined) return;
+
+          // Spread argument (`parseFloat(...rest)`) cannot be rewritten safely.
+          if (firstArg.type === AST_NODE_TYPES.SpreadElement) return;
+
+          // The argument must be purely `string` so the autofix is type-safe
+          // against `Num.safeParseFloat(s: string)`. Without type information,
+          // skip.
+          if (services?.program == null) return;
+
+          const checker = services.program.getTypeChecker();
+
+          const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
+
+          if (tsNode === undefined) return;
+
+          const argType = checker.getTypeAtLocation(tsNode);
+
+          if (!isStringType(argType)) return;
+
+          mut_nodesToFix.push({ node, argExpression: firstArg });
+        },
+        'Program:exit': () => {
+          const namedImports = getNamedImports(tsDataForgeImport);
+
+          const missingImports = (['Num', 'Result'] as const).filter(
+            (name) => !namedImports.includes(name),
+          );
+
+          for (const [
+            index,
+            { node, argExpression },
+          ] of mut_nodesToFix.entries()) {
+            const argText = sourceCode.getText(argExpression);
+
+            const originalText = sourceCode.getText(node);
+
+            context.report({
+              node,
+              messageId: 'useSafeParseFloat',
+              data: {
+                original: originalText,
+                argName: argText,
+              },
+              fix: (fixer) => {
+                const core = `Result.unwrapOkOr(Num.safeParseFloat(${argText}), Number.NaN)`;
+
+                const importFixes =
+                  index === 0 && missingImports.length > 0
+                    ? buildImportFixes(
+                        fixer,
+                        program,
+                        tsDataForgeImport,
+                        missingImports,
+                      )
+                    : [];
+
+                return [...importFixes, fixer.replaceText(node, core)];
+              },
+            });
+          }
+        },
+      };
+    },
+    defaultOptions: [],
+  } as const;

package/src/rules/prefer-num-safe-parse-float.test.mts

@@ -0,0 +1,163 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferNumSafeParseFloat } from './prefer-num-safe-parse-float.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-num-safe-parse-float', () => {
+  tester.run('prefer-num-safe-parse-float', preferNumSafeParseFloat, {
+    valid: [
+      {
+        name: 'ignores number arguments to Number() (autofix would be unsafe)',
+        code: dedent`
+          const x = 42;
+          const n = Number(x);
+        `,
+      },
+      {
+        name: 'ignores boolean arguments to Number()',
+        code: dedent`
+          const b = true;
+          const n = Number(b);
+        `,
+      },
+      {
+        name: 'ignores never-typed arguments (string & number = never)',
+        code: dedent`
+          declare const x: string & number;
+          const n = parseFloat(x);
+        `,
+      },
+      {
+        name: 'ignores spread arguments',
+        code: dedent`
+          declare const args: [string];
+          const n = parseFloat(...args);
+        `,
+      },
+      {
+        name: 'ignores parseInt (handled by prefer-num-safe-parse-int)',
+        code: dedent`
+          const s = "123";
+          const n = parseInt(s, 10);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'replaces parseFloat(s) and imports Num + Result',
+        code: dedent`
+          const s = "3.14";
+          const n = parseFloat(s);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "3.14";
+          const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+      {
+        name: 'replaces Number.parseFloat(s)',
+        code: dedent`
+          const s = "3.14";
+          const n = Number.parseFloat(s);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "3.14";
+          const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+      {
+        name: 'replaces Number(s) when s is a string',
+        code: dedent`
+          const s = "3.14";
+          const n = Number(s);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "3.14";
+          const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+      {
+        name: 'adds only the missing Result import when Num is present',
+        code: dedent`
+          import { Num } from 'ts-data-forge';
+
+          const s = "3.14";
+          const n = parseFloat(s);
+        `,
+        output: dedent`
+          import { Result } from 'ts-data-forge';
+          import { Num } from 'ts-data-forge';
+
+          const s = "3.14";
+          const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+      {
+        name: 'preserves a complex string argument expression',
+        code: dedent`
+          const get = (k: string): string => k;
+          const n = parseFloat(get("x").trim());
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const get = (k: string): string => k;
+          const n = Result.unwrapOkOr(Num.safeParseFloat(get("x").trim()), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+      {
+        name: 'replaces Number(s) with a string literal argument',
+        code: dedent`
+          const n = Number("3.14");
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const n = Result.unwrapOkOr(Num.safeParseFloat("3.14"), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+      {
+        name: 'replaces all three forms in one file',
+        code: dedent`
+          const s = "1.5";
+          const a = parseFloat(s);
+          const b = Number.parseFloat(s);
+          const c = Number(s);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "1.5";
+          const a = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+          const b = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+          const c = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+        `,
+        errors: [
+          { messageId: 'useSafeParseFloat' },
+          { messageId: 'useSafeParseFloat' },
+          { messageId: 'useSafeParseFloat' },
+        ],
+      },
+    ],
+  });
+}, 20000);