@futdevpro/dynamo-eslint 1.15.22 → 1.15.28

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

@@ -1,82 +1,82 @@
-import noJsExtensionRule from './no-js-import';
-
-describe('| no-js-import', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noJsExtensionRule.meta?.type).toBe('suggestion');
-    expect(noJsExtensionRule.meta?.docs?.description).toContain('.js');
-    expect(noJsExtensionRule.meta?.fixable).toBe('code');
-  });
-
-  it('| should have create function that returns object with ImportDeclaration method', () => {
-    const mockContext = {
-      report: () => {},
-    } as any;
-
-    const result = noJsExtensionRule.create(mockContext);
-
-    expect(typeof result).toBe('object');
-    expect(typeof result.ImportDeclaration).toBe('function');
-  });
-
-  it('| should detect forbidden .js extension imports', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('forbiddenJsExtension');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'ImportDeclaration',
-      source: { value: './some-file.js' },
-      loc: { start: { line: 1 }, end: { line: 1 } },
-    } as any;
-
-    const rule = noJsExtensionRule.create(mockContext);
-
-    rule.ImportDeclaration(mockNode);
-  });
-
-  it('| should not report errors for imports without .js extension', () => {
-    const mockContext = {
-      report: (options: any) => {
-        // Should not be called for imports without .js extension
-        fail('Should not report errors for imports without .js extension');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'ImportDeclaration',
-      source: { value: './some-file' },
-      loc: { start: { line: 1 }, end: { line: 1 } },
-    } as any;
-
-    const rule = noJsExtensionRule.create(mockContext);
-
-    rule.ImportDeclaration(mockNode);
-    
-    // If we get here without the report function being called, the test passes
-    expect(true).toBe(true);
-  });
-
-  it('| should not report errors for imports with .ts extension', () => {
-    const mockContext = {
-      report: (options: any) => {
-        // Should not be called for imports with .ts extension
-        fail('Should not report errors for imports with .ts extension');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'ImportDeclaration',
-      source: { value: './some-file.ts' },
-      loc: { start: { line: 1 }, end: { line: 1 } },
-    } as any;
-
-    const rule = noJsExtensionRule.create(mockContext);
-
-    rule.ImportDeclaration(mockNode);
-    
-    // If we get here without the report function being called, the test passes
-    expect(true).toBe(true);
-  });
-});
+import noJsExtensionRule from './no-js-import';
+
+describe('| no-js-import', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(noJsExtensionRule.meta?.type).toBe('suggestion');
+    expect(noJsExtensionRule.meta?.docs?.description).toContain('.js');
+    expect(noJsExtensionRule.meta?.fixable).toBe('code');
+  });
+
+  it('| should have create function that returns object with ImportDeclaration method', () => {
+    const mockContext = {
+      report: () => {},
+    } as any;
+
+    const result = noJsExtensionRule.create(mockContext);
+
+    expect(typeof result).toBe('object');
+    expect(typeof result.ImportDeclaration).toBe('function');
+  });
+
+  it('| should detect forbidden .js extension imports', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('forbiddenJsExtension');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'ImportDeclaration',
+      source: { value: './some-file.js' },
+      loc: { start: { line: 1 }, end: { line: 1 } },
+    } as any;
+
+    const rule = noJsExtensionRule.create(mockContext);
+
+    rule.ImportDeclaration(mockNode);
+  });
+
+  it('| should not report errors for imports without .js extension', () => {
+    const mockContext = {
+      report: (options: any) => {
+        // Should not be called for imports without .js extension
+        fail('Should not report errors for imports without .js extension');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'ImportDeclaration',
+      source: { value: './some-file' },
+      loc: { start: { line: 1 }, end: { line: 1 } },
+    } as any;
+
+    const rule = noJsExtensionRule.create(mockContext);
+
+    rule.ImportDeclaration(mockNode);
+    
+    // If we get here without the report function being called, the test passes
+    expect(true).toBe(true);
+  });
+
+  it('| should not report errors for imports with .ts extension', () => {
+    const mockContext = {
+      report: (options: any) => {
+        // Should not be called for imports with .ts extension
+        fail('Should not report errors for imports with .ts extension');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'ImportDeclaration',
+      source: { value: './some-file.ts' },
+      loc: { start: { line: 1 }, end: { line: 1 } },
+    } as any;
+
+    const rule = noJsExtensionRule.create(mockContext);
+
+    rule.ImportDeclaration(mockNode);
+    
+    // If we get here without the report function being called, the test passes
+    expect(true).toBe(true);
+  });
+});

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

@@ -1,45 +1,45 @@
-import { Rule } from 'eslint';
-
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: { description: 'Forbid imports with ".js" extension' },
-    schema: [],
-    messages: {
-      forbiddenJsExtension: 'Import with ".js" extension is forbidden. Use ".ts" or no extension.',
-    },
-    fixable: 'code',
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    // List of allowed packages that can use .js extension
-    const allowedJsPackages = [
-      'discord.js',
-    ];
-
-    return {
-      ImportDeclaration(node): void {
-        try {
-          const source: string = node.source?.value as string;
-          
-          if (source && source.endsWith('.js')) {
-            // 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);
-        }
-      },
-    };
-  },
-};
-
-export default rule;
+import { Rule } from 'eslint';
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: { description: 'Forbid imports with ".js" extension' },
+    schema: [],
+    messages: {
+      forbiddenJsExtension: 'Import with ".js" extension is forbidden. Use ".ts" or no extension.',
+    },
+    fixable: 'code',
+  },
+  create(context: Rule.RuleContext): Rule.RuleListener {
+    // List of allowed packages that can use .js extension
+    const allowedJsPackages = [
+      'discord.js',
+    ];
+
+    return {
+      ImportDeclaration(node): void {
+        try {
+          const source: string = node.source?.value as string;
+          
+          if (source && source.endsWith('.js')) {
+            // 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);
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/src/plugin/rules/naming-patterns.spec.ts

@@ -1,127 +1,189 @@
-import namingPatternsRule from './naming-patterns';
-
-describe('| naming-patterns', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(namingPatternsRule.meta?.type).toBe('suggestion');
-    expect(namingPatternsRule.meta?.docs?.description).toContain('naming conventions');
-  });
-
-  it('| should expose PropertyDefinition / ClassDeclaration / TSEnumDeclaration visitors for non-spec files', () => {
-    const mockContext: any = {
-      filename: '/x/foo.ts',
-      report: () => {},
-      options: [],
-    };
-    const result: any = namingPatternsRule.create(mockContext);
-    expect(typeof result.PropertyDefinition).toBe('function');
-    expect(typeof result.ClassDeclaration).toBe('function');
-    expect(typeof result.TSEnumDeclaration).toBe('function');
-  });
-
-  it('| should skip .spec.ts files entirely', () => {
-    const mockContext: any = {
-      filename: '/x/foo.spec.ts',
-      report: () => {},
-      options: [],
-    };
-    const result: any = namingPatternsRule.create(mockContext);
-    expect(result.PropertyDefinition).toBeUndefined();
-  });
-
-  it('| should report class without required postfix in *.data-model.ts', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.data-model.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'fileClassPostfix') {
-          reportCalled = true;
-          expect(options.data.requiredPostfix).toBe('_DataModel');
-        }
-      },
-      options: [],
-    };
-    const rule: any = namingPatternsRule.create(mockContext);
-    const mockNode: any = { id: { name: 'User' } };
-    rule.ClassDeclaration(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should NOT report class with correct postfix in *.data-model.ts', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.data-model.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'fileClassPostfix') {
-          reportCalled = true;
-        }
-      },
-      options: [],
-    };
-    const rule: any = namingPatternsRule.create(mockContext);
-    const mockNode: any = { id: { name: 'User_DataModel' } };
-    rule.ClassDeclaration(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should report non-camelCase enum key in *.type-enum.ts', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user-status.type-enum.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'enumKeyCamel') {
-          reportCalled = true;
-        }
-      },
-      options: [],
-    };
-    const rule: any = namingPatternsRule.create(mockContext);
-    const mockNode: any = {
-      members: [
-        { id: { name: 'NotCamelCase' }, initializer: null },
-      ],
-    };
-    rule.TSEnumDeclaration(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report non-kebab-case string value in enum', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user-status.type-enum.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'enumValueKebab') {
-          reportCalled = true;
-        }
-      },
-      options: [],
-    };
-    const rule: any = namingPatternsRule.create(mockContext);
-    const mockNode: any = {
-      members: [
-        {
-          id: { name: 'activeUser' },
-          initializer: { type: 'Literal', value: 'NotKebabCase' },
-        },
-      ],
-    };
-    rule.TSEnumDeclaration(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should respect `checks` option and disable booleanIsPrefix', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.ts',
-      report: () => { reportCalled = true; },
-      options: [{ checks: { booleanIsPrefix: false }}],
-    };
-    const rule: any = namingPatternsRule.create(mockContext);
-    const mockNode: any = {
-      key: { type: 'Identifier', name: 'active' },
-      typeAnnotation: { typeAnnotation: { type: 'TSBooleanKeyword' }},
-      value: null,
-    };
-    rule.PropertyDefinition(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-});
+import namingPatternsRule from './naming-patterns';
+
+describe('| naming-patterns', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(namingPatternsRule.meta?.type).toBe('suggestion');
+    expect(namingPatternsRule.meta?.docs?.description).toContain('naming conventions');
+  });
+
+  it('| should expose PropertyDefinition / ClassDeclaration / TSEnumDeclaration visitors for non-spec files', () => {
+    const mockContext: any = {
+      filename: '/x/foo.ts',
+      report: () => {},
+      options: [],
+    };
+    const result: any = namingPatternsRule.create(mockContext);
+    expect(typeof result.PropertyDefinition).toBe('function');
+    expect(typeof result.ClassDeclaration).toBe('function');
+    expect(typeof result.TSEnumDeclaration).toBe('function');
+  });
+
+  it('| should skip .spec.ts files entirely', () => {
+    const mockContext: any = {
+      filename: '/x/foo.spec.ts',
+      report: () => {},
+      options: [],
+    };
+    const result: any = namingPatternsRule.create(mockContext);
+    expect(result.PropertyDefinition).toBeUndefined();
+  });
+
+  it('| should report class without required postfix in *.data-model.ts', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user.data-model.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'fileClassPostfix') {
+          reportCalled = true;
+          expect(options.data.requiredPostfix).toBe('_DataModel');
+        }
+      },
+      options: [],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    const mockNode: any = { id: { name: 'User' } };
+    rule.ClassDeclaration(mockNode);
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should NOT report class with correct postfix in *.data-model.ts', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user.data-model.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'fileClassPostfix') {
+          reportCalled = true;
+        }
+      },
+      options: [],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    const mockNode: any = { id: { name: 'User_DataModel' } };
+    rule.ClassDeclaration(mockNode);
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should report non-camelCase enum key in *.type-enum.ts', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user-status.type-enum.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'enumKeyCamel') {
+          reportCalled = true;
+        }
+      },
+      options: [],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    const mockNode: any = {
+      members: [
+        { id: { name: 'NotCamelCase' }, initializer: null },
+      ],
+    };
+    rule.TSEnumDeclaration(mockNode);
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report non-kebab-case string value in enum', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user-status.type-enum.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'enumValueKebab') {
+          reportCalled = true;
+        }
+      },
+      options: [],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    const mockNode: any = {
+      members: [
+        {
+          id: { name: 'activeUser' },
+          initializer: { type: 'Literal', value: 'NotKebabCase' },
+        },
+      ],
+    };
+    rule.TSEnumDeclaration(mockNode);
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should respect `checks` option and disable booleanIsPrefix', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user.ts',
+      report: () => { reportCalled = true; },
+      options: [{ checks: { booleanIsPrefix: false }}],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    const mockNode: any = {
+      key: { type: 'Identifier', name: 'active' },
+      typeAnnotation: { typeAnnotation: { type: 'TSBooleanKeyword' }},
+      value: null,
+    };
+    rule.PropertyDefinition(mockNode);
+    expect(reportCalled).toBe(false);
+  });
+
+  // ─ BFR-ADVENTOR-018 — kanonikus `ls` nyelv-service kivétel a service-property-postfix alól ─
+
+  /** Helper: inject(<serviceName>) CallExpression mock. */
+  function buildInjectNode(propName: string, serviceName: string): any {
+    return {
+      key: { type: 'Identifier', name: propName },
+      value: {
+        type: 'CallExpression',
+        callee: { type: 'Identifier', name: 'inject' },
+        arguments: [ { type: 'Identifier', name: serviceName } ],
+      },
+    };
+  }
+
+  it('| BFR-ADVENTOR-018: `ls = inject(A_Language_ControlService)` NEM lelet (beépített kivétel)', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/app.component.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'servicePropertyPostfix') {
+          reportCalled = true;
+        }
+      },
+      options: [],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    rule.PropertyDefinition(buildInjectNode('ls', 'A_Language_ControlService'));
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| BFR-ADVENTOR-018: más rövid név ControlService-re továbbra is lelet', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/app.component.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'servicePropertyPostfix') {
+          reportCalled = true;
+        }
+      },
+      options: [],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    rule.PropertyDefinition(buildInjectNode('auth', 'A_Auth_ControlService'));
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| BFR-ADVENTOR-018: projekt-szintű allowedPropertyNames opció bővíti a kivétel-listát', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/app.component.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'servicePropertyPostfix') {
+          reportCalled = true;
+        }
+      },
+      options: [ { allowedPropertyNames: [ 'store' ] } ],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    rule.PropertyDefinition(buildInjectNode('store', 'A_Store_ControlService'));
+    expect(reportCalled).toBe(false);
+  });
+});