@futdevpro/dynamo-eslint 1.14.4 → 1.14.7

package/src/plugin/rules/prefer-enum-over-string-union.ts

@@ -0,0 +1,333 @@
+import { Rule } from 'eslint';
+
+interface RuleOptions {
+  minValues?: number;
+  allowTypeAliases?: boolean;
+}
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Suggest using enums instead of union types of string literals',
+      recommended: true,
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          minValues: {
+            type: 'number',
+            minimum: 2,
+            default: 3,
+          },
+          allowTypeAliases: {
+            type: 'boolean',
+            default: false,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      preferEnum: 'Consider using an enum instead of a union type of {{count}} string literals.',
+    },
+    fixable: 'code',
+  },
+  create(context) {
+    const options: RuleOptions = context.options[0] || {};
+    const minValues: number = options.minValues || 3;
+    const allowTypeAliases: boolean = options.allowTypeAliases || false;
+
+    /**
+     * Check if a union type is composed solely of string literals
+     */
+    function isStringLiteralUnion(node: any): boolean {
+      if (node.type !== 'TSUnionType') {
+        return false;
+      }
+
+      if (!node.types || !Array.isArray(node.types)) {
+        return false;
+      }
+
+      return node.types.every((type: any) => 
+        type.type === 'TSLiteralType' && 
+        typeof type.literal?.value === 'string'
+      );
+    }
+
+    /**
+     * Check if a property is an Angular component input
+     */
+    function isAngularInput(node: any): boolean {
+      try {
+        // Check for @Input() decorator (old style)
+        if (node.decorators && Array.isArray(node.decorators)) {
+          const hasInputDecorator = node.decorators.some((decorator: any) => {
+            const expression = decorator.expression;
+
+            return expression?.type === 'CallExpression' && 
+                   expression.callee?.name === 'Input';
+          });
+
+          if (hasInputDecorator) {
+            return true;
+          }
+        }
+
+        // Check for input() or input.required() signal (new style)
+        if (node.value?.type === 'CallExpression') {
+          const callee = node.value.callee;
+
+          // Direct call: input()
+          if (callee?.name === 'input') {
+            return true;
+          }
+
+          // Member call: input.required()
+          if (callee?.object?.name === 'input' && callee?.property?.name === 'required') {
+            return true;
+          }
+        }
+
+        return false;
+      } catch (error) {
+        console.error('[prefer-enum-over-string-union] Error checking Angular input:', error);
+
+        return false;
+      }
+    }
+
+    /**
+     * Check if a union type meets the minimum threshold
+     */
+    function meetsThreshold(node: any): boolean {
+      if (node.type !== 'TSUnionType' || !node.types) {
+        return false;
+      }
+
+      const stringLiteralCount = node.types.filter((type: any) => 
+        type.type === 'TSLiteralType' && 
+        typeof type.literal?.value === 'string'
+      ).length;
+
+      return stringLiteralCount >= minValues;
+    }
+
+    /**
+     * Generate enum name suggestion based on context
+     */
+    function generateEnumName(node: any, parent: any): string {
+      try {
+        // For type aliases, use the type name
+        if (parent?.type === 'TSTypeAliasDeclaration' && parent.id?.name) {
+          return parent.id.name;
+        }
+
+        // For properties, use property name + "Enum"
+        if (node.type === 'TSPropertySignature' && node.key?.name) {
+          return `${node.key.name.charAt(0).toUpperCase() + node.key.name.slice(1)}Enum`;
+        }
+
+        // For class properties, use property name + "Enum"
+        if (parent?.type === 'PropertyDefinition' && parent.key?.name) {
+          return `${parent.key.name.charAt(0).toUpperCase() + parent.key.name.slice(1)}Enum`;
+        }
+
+        // Default fallback
+        return 'StatusEnum';
+      } catch (error) {
+        console.error('[prefer-enum-over-string-union] Error generating enum name:', error);
+
+        return 'StatusEnum';
+      }
+    }
+
+    /**
+     * Generate enum values from string literals
+     */
+    function generateEnumValues(node: any): string[] {
+      if (node.type !== 'TSUnionType' || !node.types) {
+        return [];
+      }
+
+      return node.types
+        .filter((type: any) => 
+          type.type === 'TSLiteralType' && 
+          typeof type.literal?.value === 'string'
+        )
+        .map((type: any) => {
+          const value = type.literal.value;
+
+          // Convert to PascalCase for enum key
+          return value
+            .split(/[-_\s]+/)
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+        });
+    }
+
+    /**
+     * Report violation with enum suggestion
+     */
+    function reportViolation(node: any, parent: any, unionNode: any): void {
+      const stringLiteralCount = unionNode.types.filter((type: any) => 
+        type.type === 'TSLiteralType' && 
+        typeof type.literal?.value === 'string'
+      ).length;
+
+      const enumName = generateEnumName(node, parent);
+      const enumValues = generateEnumValues(unionNode);
+
+      context.report({
+        node: unionNode,
+        messageId: 'preferEnum',
+        data: {
+          count: stringLiteralCount.toString(),
+        },
+        fix(fixer) {
+          try {
+            const enumDeclaration = `enum ${enumName} {\n  ${enumValues.map((key, index) => {
+              const value = unionNode.types[index].literal.value;
+
+              return `${key} = '${value}'`;
+            }).join(',\n  ')}\n}`;
+
+            // For type aliases, replace the entire declaration
+            if (parent?.type === 'TSTypeAliasDeclaration') {
+              const typeText = context.sourceCode.getText(parent);
+              const newText = typeText.replace(/=.*/, `= ${enumName};`);
+
+              return fixer.replaceText(parent, newText);
+            }
+
+            // For other cases, suggest enum creation (no auto-fix for now)
+            return null;
+          } catch (fixError) {
+            console.error('[prefer-enum-over-string-union] Error in fix function:', fixError);
+
+            return null;
+          }
+        },
+      });
+    }
+
+    return {
+      // Type aliases
+      TSTypeAliasDeclaration(node: any) {
+        try {
+          if (allowTypeAliases) {
+            return;
+          }
+
+          if (isStringLiteralUnion(node.typeAnnotation) && meetsThreshold(node.typeAnnotation)) {
+            reportViolation(node.typeAnnotation, node, node.typeAnnotation);
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in TSTypeAliasDeclaration visitor:', error);
+        }
+      },
+
+      // Interface/type properties
+      TSPropertySignature(node: any) {
+        try {
+          if (isAngularInput(node)) {
+            return;
+          }
+
+          if (node.typeAnnotation && 
+              isStringLiteralUnion(node.typeAnnotation.typeAnnotation) && 
+              meetsThreshold(node.typeAnnotation.typeAnnotation)) {
+            reportViolation(node, node.parent, node.typeAnnotation.typeAnnotation);
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in TSPropertySignature visitor:', error);
+        }
+      },
+
+      // Class properties
+      PropertyDefinition(node: any) {
+        try {
+          if (isAngularInput(node)) {
+            return;
+          }
+
+          if (node.typeAnnotation && 
+              isStringLiteralUnion(node.typeAnnotation.typeAnnotation) && 
+              meetsThreshold(node.typeAnnotation.typeAnnotation)) {
+            reportViolation(node, node.parent, node.typeAnnotation.typeAnnotation);
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in PropertyDefinition visitor:', error);
+        }
+      },
+
+      // Function parameters
+      FunctionDeclaration(node: any) {
+        try {
+          if (node.params && Array.isArray(node.params)) {
+            node.params.forEach((param: any) => {
+              if (param.typeAnnotation && 
+                  isStringLiteralUnion(param.typeAnnotation.typeAnnotation) && 
+                  meetsThreshold(param.typeAnnotation.typeAnnotation)) {
+                reportViolation(param, node, param.typeAnnotation.typeAnnotation);
+              }
+            });
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in FunctionDeclaration visitor:', error);
+        }
+      },
+
+      // Arrow function parameters
+      ArrowFunctionExpression(node: any) {
+        try {
+          if (node.params && Array.isArray(node.params)) {
+            node.params.forEach((param: any) => {
+              if (param.typeAnnotation && 
+                  isStringLiteralUnion(param.typeAnnotation.typeAnnotation) && 
+                  meetsThreshold(param.typeAnnotation.typeAnnotation)) {
+                reportViolation(param, node, param.typeAnnotation.typeAnnotation);
+              }
+            });
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in ArrowFunctionExpression visitor:', error);
+        }
+      },
+
+      // Variable declarations
+      VariableDeclarator(node: any) {
+        try {
+          if (node.typeAnnotation && 
+              isStringLiteralUnion(node.typeAnnotation.typeAnnotation) && 
+              meetsThreshold(node.typeAnnotation.typeAnnotation)) {
+            reportViolation(node, node.parent, node.typeAnnotation.typeAnnotation);
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in VariableDeclarator visitor:', error);
+        }
+      },
+
+      // Method signatures
+      TSMethodSignature(node: any) {
+        try {
+          if (node.params && Array.isArray(node.params)) {
+            node.params.forEach((param: any) => {
+              if (param.typeAnnotation && 
+                  isStringLiteralUnion(param.typeAnnotation.typeAnnotation) && 
+                  meetsThreshold(param.typeAnnotation.typeAnnotation)) {
+                reportViolation(param, node, param.typeAnnotation.typeAnnotation);
+              }
+            });
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in TSMethodSignature visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/src/plugin/rules/prefer-interface-over-duplicate-types.spec.ts

@@ -0,0 +1,374 @@
+import preferInterfaceRule from './prefer-interface-over-duplicate-types';
+
+describe('| prefer-interface-over-duplicate-types', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(preferInterfaceRule.meta?.type).toBe('suggestion');
+    expect(preferInterfaceRule.meta?.docs?.description).toContain('Suggest creating interfaces');
+    expect(preferInterfaceRule.meta?.fixable).toBe('code');
+  });
+
+  it('| should have create function that returns visitor object', () => {
+    const mockContext = {
+      report: () => {},
+      options: [{ threshold: 3 }],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const result = preferInterfaceRule.create(mockContext);
+
+    expect(typeof result).toBe('object');
+    expect(typeof result.TSTypeLiteral).toBe('function');
+    expect(typeof result['Program:exit']).toBe('function');
+  });
+
+  it('| should not report when object type is used less than threshold', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ threshold: 3 }],
+      sourceCode: {
+        getText: () => '{ name: string; age: number }',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    // Simulate 2 usages (below threshold of 3)
+    const mockNode1 = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    const mockNode2 = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode1);
+    rule.TSTypeLiteral(mockNode2);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should report when object type is used at or above threshold', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('preferInterface');
+        expect(options.data.count).toBe('3');
+        expect(options.data.interfaceName).toContain('Interface');
+      },
+      options: [{ threshold: 3 }],
+      sourceCode: {
+        getText: () => '{ name: string; age: number }',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    // Simulate 3 usages (at threshold)
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode);
+    rule.TSTypeLiteral(mockNode);
+    rule.TSTypeLiteral(mockNode);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle custom threshold', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('2');
+      },
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '{ name: string }',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode);
+    rule.TSTypeLiteral(mockNode);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle structural equivalence (different property order)', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('2');
+      },
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    // First object: { name: string, age: number }
+    const mockNode1 = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    // Second object: { age: number, name: string } (different order)
+    const mockNode2 = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode1);
+    rule.TSTypeLiteral(mockNode2);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle optional properties', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('2');
+      },
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } }, optional: true },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode);
+    rule.TSTypeLiteral(mockNode);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle readonly properties', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('2');
+      },
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } }, readonly: true },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode);
+    rule.TSTypeLiteral(mockNode);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should provide auto-fix functionality', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.fix).toBeDefined();
+        expect(typeof options.fix).toBe('function');
+      },
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '{ name: string; age: number }',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode);
+    rule.TSTypeLiteral(mockNode);
+    rule['Program:exit']({} as any);
+  });
+
+  it('| should handle default threshold when no options provided', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('3');
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode);
+    rule.TSTypeLiteral(mockNode);
+    rule.TSTypeLiteral(mockNode);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle complex nested types', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('2');
+      },
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { 
+          type: 'TSPropertySignature', 
+          key: { name: 'user' }, 
+          typeAnnotation: { 
+            typeAnnotation: { 
+              type: 'TSTypeLiteral',
+              members: [
+                { type: 'TSPropertySignature', key: { name: 'id' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+                { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+              ],
+            }, 
+          }, 
+        },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode);
+    rule.TSTypeLiteral(mockNode);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle error cases gracefully', () => {
+    const mockContext = {
+      report: () => {},
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => {
+          throw new Error('Scope error'); 
+        },
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+      ],
+    } as any;
+
+    // Should not throw error
+    expect(() => {
+      rule.TSTypeLiteral(mockNode);
+      rule.TSTypeLiteral(mockNode);
+      rule['Program:exit']({} as any);
+    }).not.toThrow();
+  });
+});