@futdevpro/dynamo-eslint 1.14.4 → 1.14.7

package/src/plugin/rules/import/no-js-import.ts

@@ -10,27 +10,29 @@ const rule: Rule.RuleModule = {
     },
     fixable: 'code',
   },
-  create(context) {
+  create(context: Rule.RuleContext): Rule.RuleListener {
+    // List of allowed packages that can use .js extension
+    const allowedJsPackages = [
+      'discord.js',
+    ];
+
     return {
-      ImportDeclaration(node: any) {
+      ImportDeclaration(node): void {
         try {
-          const source = node.source?.value as string;
+          const source: string = node.source?.value as string;
           
           if (source && source.endsWith('.js')) {
-            context.report({
-              node: node.source,
-              messageId: 'forbiddenJsExtension',
-              fix(fixer) {
-                try {
-                  // Remove .js extension
-                  const newSource = source.replace(/\.js$/, '');
-                  return fixer.replaceText(node.source, `'${newSource}'`);
-                } catch (fixError) {
-                  console.error('[no-js-import] Error in fix function:', fixError);
-                  return null;
-                }
-              },
-            });
+            // Check if the import is from an allowed package
+            const isAllowedPackage = allowedJsPackages.some((pkg: string): boolean => 
+              source.includes(pkg) || source.startsWith(pkg)
+            );
+            
+            if (!isAllowedPackage) {
+              context.report({
+                node: node.source,
+                messageId: 'forbiddenJsExtension',
+              });
+            }
           }
         } catch (error) {
           console.error('[no-js-import] Error in ImportDeclaration visitor:', error);

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

@@ -0,0 +1,583 @@
+import preferEnumRule from './prefer-enum-over-string-union';
+
+describe('| prefer-enum-over-string-union', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(preferEnumRule.meta.type).toBe('suggestion');
+    expect(preferEnumRule.meta.docs.description).toBe('Suggest using enums instead of union types of string literals');
+    expect(preferEnumRule.meta.fixable).toBe('code');
+  });
+
+  it('| should not report when union has less than threshold values', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeAliasDeclaration',
+      id: { name: 'Status' },
+      typeAnnotation: {
+        type: 'TSUnionType',
+        types: [
+          { type: 'TSLiteralType', literal: { value: 'active' } },
+          { type: 'TSLiteralType', literal: { value: 'inactive' } },
+        ],
+      },
+    } as any;
+
+    rule.TSTypeAliasDeclaration(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should report when union has threshold or more string literals', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('preferEnum');
+        expect(options.data.count).toBe('3');
+        expect(options.fix).toBeDefined();
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => 'type Status = \'active\' | \'inactive\' | \'pending\'',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeAliasDeclaration',
+      id: { name: 'Status' },
+      typeAnnotation: {
+        type: 'TSUnionType',
+        types: [
+          { type: 'TSLiteralType', literal: { value: 'active' } },
+          { type: 'TSLiteralType', literal: { value: 'inactive' } },
+          { type: 'TSLiteralType', literal: { value: 'pending' } },
+        ],
+      },
+    } as any;
+
+    rule.TSTypeAliasDeclaration(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should not report when union contains non-string literals', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeAliasDeclaration',
+      id: { name: 'Value' },
+      typeAnnotation: {
+        type: 'TSUnionType',
+        types: [
+          { type: 'TSLiteralType', literal: { value: 'active' } },
+          { type: 'TSLiteralType', literal: { value: 'inactive' } },
+          { type: 'TSNumberKeyword' },
+        ],
+      },
+    } as any;
+
+    rule.TSTypeAliasDeclaration(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report when allowTypeAliases is true', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ minValues: 3, allowTypeAliases: true }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeAliasDeclaration',
+      id: { name: 'Status' },
+      typeAnnotation: {
+        type: 'TSUnionType',
+        types: [
+          { type: 'TSLiteralType', literal: { value: 'active' } },
+          { type: 'TSLiteralType', literal: { value: 'inactive' } },
+          { type: 'TSLiteralType', literal: { value: 'pending' } },
+        ],
+      },
+    } as any;
+
+    rule.TSTypeAliasDeclaration(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should report on interface properties', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('preferEnum');
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSPropertySignature',
+      key: { name: 'role' },
+      typeAnnotation: {
+        typeAnnotation: {
+          type: 'TSUnionType',
+          types: [
+            { type: 'TSLiteralType', literal: { value: 'admin' } },
+            { type: 'TSLiteralType', literal: { value: 'user' } },
+            { type: 'TSLiteralType', literal: { value: 'guest' } },
+          ],
+        },
+      },
+      parent: { type: 'TSInterfaceDeclaration' },
+    } as any;
+
+    rule.TSPropertySignature(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report on class properties', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('preferEnum');
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'PropertyDefinition',
+      key: { name: 'status' },
+      typeAnnotation: {
+        typeAnnotation: {
+          type: 'TSUnionType',
+          types: [
+            { type: 'TSLiteralType', literal: { value: 'active' } },
+            { type: 'TSLiteralType', literal: { value: 'inactive' } },
+            { type: 'TSLiteralType', literal: { value: 'pending' } },
+          ],
+        },
+      },
+      parent: { type: 'ClassDeclaration' },
+    } as any;
+
+    rule.PropertyDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report on function parameters', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('preferEnum');
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'FunctionDeclaration',
+      id: { name: 'setStatus' },
+      params: [
+        {
+          type: 'Identifier',
+          name: 'status',
+          typeAnnotation: {
+            typeAnnotation: {
+              type: 'TSUnionType',
+              types: [
+                { type: 'TSLiteralType', literal: { value: 'active' } },
+                { type: 'TSLiteralType', literal: { value: 'inactive' } },
+                { type: 'TSLiteralType', literal: { value: 'pending' } },
+              ],
+            },
+          },
+        },
+      ],
+    } as any;
+
+    rule.FunctionDeclaration(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report on arrow function parameters', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('preferEnum');
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'ArrowFunctionExpression',
+      params: [
+        {
+          type: 'Identifier',
+          name: 'status',
+          typeAnnotation: {
+            typeAnnotation: {
+              type: 'TSUnionType',
+              types: [
+                { type: 'TSLiteralType', literal: { value: 'active' } },
+                { type: 'TSLiteralType', literal: { value: 'inactive' } },
+                { type: 'TSLiteralType', literal: { value: 'pending' } },
+              ],
+            },
+          },
+        },
+      ],
+    } as any;
+
+    rule.ArrowFunctionExpression(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report on variable declarations', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('preferEnum');
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'VariableDeclarator',
+      id: { name: 'status' },
+      typeAnnotation: {
+        typeAnnotation: {
+          type: 'TSUnionType',
+          types: [
+            { type: 'TSLiteralType', literal: { value: 'active' } },
+            { type: 'TSLiteralType', literal: { value: 'inactive' } },
+            { type: 'TSLiteralType', literal: { value: 'pending' } },
+          ],
+        },
+      },
+      parent: { type: 'VariableDeclaration' },
+    } as any;
+
+    rule.VariableDeclarator(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should not report on Angular @Input() properties', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'PropertyDefinition',
+      key: { name: 'mode' },
+      decorators: [
+        {
+          expression: {
+            type: 'CallExpression',
+            callee: { name: 'Input' },
+          },
+        },
+      ],
+      typeAnnotation: {
+        typeAnnotation: {
+          type: 'TSUnionType',
+          types: [
+            { type: 'TSLiteralType', literal: { value: 'light' } },
+            { type: 'TSLiteralType', literal: { value: 'dark' } },
+            { type: 'TSLiteralType', literal: { value: 'auto' } },
+          ],
+        },
+      },
+      parent: { type: 'ClassDeclaration' },
+    } as any;
+
+    rule.PropertyDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report on Angular input() signal properties', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'PropertyDefinition',
+      key: { name: 'size' },
+      value: {
+        type: 'CallExpression',
+        callee: { name: 'input' },
+      },
+      typeAnnotation: {
+        typeAnnotation: {
+          type: 'TSUnionType',
+          types: [
+            { type: 'TSLiteralType', literal: { value: 'small' } },
+            { type: 'TSLiteralType', literal: { value: 'medium' } },
+            { type: 'TSLiteralType', literal: { value: 'large' } },
+          ],
+        },
+      },
+      parent: { type: 'ClassDeclaration' },
+    } as any;
+
+    rule.PropertyDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report on Angular input.required() signal properties', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'PropertyDefinition',
+      key: { name: 'theme' },
+      value: {
+        type: 'CallExpression',
+        callee: {
+          type: 'MemberExpression',
+          object: { name: 'input' },
+          property: { name: 'required' },
+        },
+      },
+      typeAnnotation: {
+        typeAnnotation: {
+          type: 'TSUnionType',
+          types: [
+            { type: 'TSLiteralType', literal: { value: 'light' } },
+            { type: 'TSLiteralType', literal: { value: 'dark' } },
+            { type: 'TSLiteralType', literal: { value: 'auto' } },
+          ],
+        },
+      },
+      parent: { type: 'ClassDeclaration' },
+    } as any;
+
+    rule.PropertyDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should handle custom minValues threshold', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('2');
+      },
+      options: [{ minValues: 2 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeAliasDeclaration',
+      id: { name: 'Binary' },
+      typeAnnotation: {
+        type: 'TSUnionType',
+        types: [
+          { type: 'TSLiteralType', literal: { value: 'yes' } },
+          { type: 'TSLiteralType', literal: { value: 'no' } },
+        ],
+      },
+    } as any;
+
+    rule.TSTypeAliasDeclaration(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle edge cases with empty strings and special characters', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('3');
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeAliasDeclaration',
+      id: { name: 'Special' },
+      typeAnnotation: {
+        type: 'TSUnionType',
+        types: [
+          { type: 'TSLiteralType', literal: { value: '' } },
+          { type: 'TSLiteralType', literal: { value: 'hello-world' } },
+          { type: 'TSLiteralType', literal: { value: 'test_value' } },
+        ],
+      },
+    } as any;
+
+    rule.TSTypeAliasDeclaration(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should provide auto-fix for type aliases', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.fix).toBeDefined();
+        expect(typeof options.fix).toBe('function');
+        
+        // Test the fix function
+        const fixResult = options.fix({
+          replaceText: (node: any, text: string) => {
+            expect(text).toContain('Status');
+
+            return [];
+          },
+        });
+        
+        expect(Array.isArray(fixResult)).toBe(true);
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => 'type Status = \'active\' | \'inactive\' | \'pending\'',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeAliasDeclaration',
+      id: { name: 'Status' },
+      typeAnnotation: {
+        type: 'TSUnionType',
+        types: [
+          { type: 'TSLiteralType', literal: { value: 'active' } },
+          { type: 'TSLiteralType', literal: { value: 'inactive' } },
+          { type: 'TSLiteralType', literal: { value: 'pending' } },
+        ],
+      },
+    } as any;
+
+    rule.TSTypeAliasDeclaration(mockNode);
+  });
+
+  it('| should handle errors gracefully', () => {
+    const mockContext = {
+      report: (options: any) => {
+        // Should not throw
+      },
+      options: [{ minValues: 3 }],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = preferEnumRule.create(mockContext);
+
+    // Test with malformed nodes
+    const malformedNode = {
+      type: 'TSTypeAliasDeclaration',
+      // Missing required properties
+    } as any;
+
+    expect(() => {
+      rule.TSTypeAliasDeclaration(malformedNode);
+    }).not.toThrow();
+  });
+});