@futdevpro/dynamo-eslint 1.15.25 → 1.15.28

package/src/plugin/rules/require-test-description-prefix.ts

@@ -1,154 +1,154 @@
-import { Rule } from 'eslint';
-
-interface RuleOptions {
-  prefix?: string;
-  testFunctions?: string[];
-}
-
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Require "| " prefix in test descriptions',
-      recommended: true,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          prefix: {
-            type: 'string',
-            default: '| ',
-          },
-          testFunctions: {
-            type: 'array',
-            items: {
-              type: 'string',
-            },
-            default: [ 'describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll' ],
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      missingPrefix: 'Test description must start with "{{prefix}}"',
-      wrongPrefix: 'Test description must start with "{{prefix}}" but found "{{found}}"',
-    },
-    fixable: 'code',
-  },
-  create(context) {
-    const options: RuleOptions = context.options[0] || {};
-    const prefix: string = options.prefix || '| ';
-    const testFunctions: string[] = options.testFunctions || 
-      [ 'describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll' ];
-
-    /**
-     * Check if a CallExpression is a test function
-     */
-    function isTestFunction(node: any): boolean {
-      try {
-        return node.type === 'CallExpression' && 
-               node.callee && 
-               node.callee.name && 
-               testFunctions.includes(node.callee.name);
-      } catch (error) {
-        console.error('[require-test-description-prefix] Error in isTestFunction:', error);
-
-        return false;
-      }
-    }
-
-    /**
-     * Check if a string has the correct prefix
-     */
-    function hasCorrectPrefix(description: string): boolean {
-      try {
-        return typeof description === 'string' && description.startsWith(prefix);
-      } catch (error) {
-        console.error('[require-test-description-prefix] Error in hasCorrectPrefix:', error);
-
-        return false;
-      }
-    }
-
-    /**
-     * Get the actual prefix found in the string
-     */
-    function getFoundPrefix(description: string): string {
-      try {
-        if (typeof description !== 'string' || description.length === 0) {
-          return '';
-        }
-        
-        // Find the first non-alphanumeric character or end of string
-        const match = description.match(/^[^a-zA-Z0-9]*/);
-
-        return match ? match[0] : '';
-      } catch (error) {
-        console.error('[require-test-description-prefix] Error in getFoundPrefix:', error);
-
-        return '';
-      }
-    }
-
-    /**
-     * Check and report on test function calls
-     */
-    function checkTestFunction(node: any): void {
-      try {
-        if (!isTestFunction(node)) {
-          return;
-        }
-
-        // Check if there are arguments
-        if (!node.arguments || node.arguments.length === 0) {
-          return;
-        }
-
-        const firstArg = node.arguments[0];
-        
-        // Only check string literals
-        if (firstArg.type !== 'Literal' || typeof firstArg.value !== 'string') {
-          return;
-        }
-
-        const description = firstArg.value;
-        
-        if (!hasCorrectPrefix(description)) {
-          const foundPrefix = getFoundPrefix(description);
-          
-          context.report({
-            node: firstArg,
-            messageId: foundPrefix ? 'wrongPrefix' : 'missingPrefix',
-            data: {
-              prefix,
-              found: foundPrefix,
-            },
-            fix(fixer) {
-              try {
-                const newText = `${prefix}${description}`;
-
-                return fixer.replaceText(firstArg, `'${newText}'`);
-              } catch (fixError) {
-                console.error('[require-test-description-prefix] Error in fix function:', fixError);
-
-                return null;
-              }
-            },
-          });
-        }
-      } catch (error) {
-        console.error('[require-test-description-prefix] Error in checkTestFunction:', error);
-      }
-    }
-
-    return {
-      CallExpression(node: any) {
-        checkTestFunction(node);
-      },
-    };
-  },
-};
-
-export default rule;
+import { Rule } from 'eslint';
+
+interface RuleOptions {
+  prefix?: string;
+  testFunctions?: string[];
+}
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require "| " prefix in test descriptions',
+      recommended: true,
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          prefix: {
+            type: 'string',
+            default: '| ',
+          },
+          testFunctions: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+            default: [ 'describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll' ],
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      missingPrefix: 'Test description must start with "{{prefix}}"',
+      wrongPrefix: 'Test description must start with "{{prefix}}" but found "{{found}}"',
+    },
+    fixable: 'code',
+  },
+  create(context) {
+    const options: RuleOptions = context.options[0] || {};
+    const prefix: string = options.prefix || '| ';
+    const testFunctions: string[] = options.testFunctions || 
+      [ 'describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll' ];
+
+    /**
+     * Check if a CallExpression is a test function
+     */
+    function isTestFunction(node: any): boolean {
+      try {
+        return node.type === 'CallExpression' && 
+               node.callee && 
+               node.callee.name && 
+               testFunctions.includes(node.callee.name);
+      } catch (error) {
+        console.error('[require-test-description-prefix] Error in isTestFunction:', error);
+
+        return false;
+      }
+    }
+
+    /**
+     * Check if a string has the correct prefix
+     */
+    function hasCorrectPrefix(description: string): boolean {
+      try {
+        return typeof description === 'string' && description.startsWith(prefix);
+      } catch (error) {
+        console.error('[require-test-description-prefix] Error in hasCorrectPrefix:', error);
+
+        return false;
+      }
+    }
+
+    /**
+     * Get the actual prefix found in the string
+     */
+    function getFoundPrefix(description: string): string {
+      try {
+        if (typeof description !== 'string' || description.length === 0) {
+          return '';
+        }
+        
+        // Find the first non-alphanumeric character or end of string
+        const match = description.match(/^[^a-zA-Z0-9]*/);
+
+        return match ? match[0] : '';
+      } catch (error) {
+        console.error('[require-test-description-prefix] Error in getFoundPrefix:', error);
+
+        return '';
+      }
+    }
+
+    /**
+     * Check and report on test function calls
+     */
+    function checkTestFunction(node: any): void {
+      try {
+        if (!isTestFunction(node)) {
+          return;
+        }
+
+        // Check if there are arguments
+        if (!node.arguments || node.arguments.length === 0) {
+          return;
+        }
+
+        const firstArg = node.arguments[0];
+        
+        // Only check string literals
+        if (firstArg.type !== 'Literal' || typeof firstArg.value !== 'string') {
+          return;
+        }
+
+        const description = firstArg.value;
+        
+        if (!hasCorrectPrefix(description)) {
+          const foundPrefix = getFoundPrefix(description);
+          
+          context.report({
+            node: firstArg,
+            messageId: foundPrefix ? 'wrongPrefix' : 'missingPrefix',
+            data: {
+              prefix,
+              found: foundPrefix,
+            },
+            fix(fixer) {
+              try {
+                const newText = `${prefix}${description}`;
+
+                return fixer.replaceText(firstArg, `'${newText}'`);
+              } catch (fixError) {
+                console.error('[require-test-description-prefix] Error in fix function:', fixError);
+
+                return null;
+              }
+            },
+          });
+        }
+      } catch (error) {
+        console.error('[require-test-description-prefix] Error in checkTestFunction:', error);
+      }
+    }
+
+    return {
+      CallExpression(node: any) {
+        checkTestFunction(node);
+      },
+    };
+  },
+};
+
+export default rule;

package/src/plugin/rules/ts/data-model-extends.spec.ts

@@ -1,84 +1,84 @@
-import dataModelExtendsRule from './data-model-extends';
-
-describe('| data-model-extends', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(dataModelExtendsRule.meta?.type).toBe('suggestion');
-    expect(dataModelExtendsRule.meta?.messages?.missingExtends).toBeDefined();
-    expect(dataModelExtendsRule.meta?.messages?.parallelDateField).toBeDefined();
-  });
-
-  it('| should skip non-data-model files', () => {
-    const mockContext: any = { filename: '/x/foo.ts', report: () => {}, options: [] };
-    const result: any = dataModelExtendsRule.create(mockContext);
-    expect(result.ClassDeclaration).toBeUndefined();
-  });
-
-  it('| should report when data-model class has no `extends`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.data-model.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'missingExtends') {
-          reportCalled = true;
-          expect(options.data.className).toBe('User_DataModel');
-        }
-      },
-      options: [],
-    };
-    const rule: any = dataModelExtendsRule.create(mockContext);
-    const mockNode: any = {
-      id: { name: 'User_DataModel' },
-      superClass: null,
-      body: { body: [] },
-    };
-    rule.ClassDeclaration(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should not report when extending DyFM_Metadata', () => {
-    let missingReported: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.data-model.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'missingExtends') {
-          missingReported = true;
-        }
-      },
-      options: [],
-    };
-    const rule: any = dataModelExtendsRule.create(mockContext);
-    const mockNode: any = {
-      id: { name: 'User_DataModel' },
-      superClass: { type: 'Identifier', name: 'DyFM_Metadata' },
-      body: { body: [] },
-    };
-    rule.ClassDeclaration(mockNode);
-    expect(missingReported).toBe(false);
-  });
-
-  it('| should report parallel date field `createdAt`', () => {
-    let parallelReported: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.data-model.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'parallelDateField') {
-          parallelReported = true;
-          expect(options.data.fieldName).toBe('createdAt');
-        }
-      },
-      options: [],
-    };
-    const rule: any = dataModelExtendsRule.create(mockContext);
-    const mockNode: any = {
-      id: { name: 'User_DataModel' },
-      superClass: { type: 'Identifier', name: 'DyFM_Metadata' },
-      body: {
-        body: [
-          { type: 'PropertyDefinition', key: { type: 'Identifier', name: 'createdAt' } },
-        ],
-      },
-    };
-    rule.ClassDeclaration(mockNode);
-    expect(parallelReported).toBe(true);
-  });
-});
+import dataModelExtendsRule from './data-model-extends';
+
+describe('| data-model-extends', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(dataModelExtendsRule.meta?.type).toBe('suggestion');
+    expect(dataModelExtendsRule.meta?.messages?.missingExtends).toBeDefined();
+    expect(dataModelExtendsRule.meta?.messages?.parallelDateField).toBeDefined();
+  });
+
+  it('| should skip non-data-model files', () => {
+    const mockContext: any = { filename: '/x/foo.ts', report: () => {}, options: [] };
+    const result: any = dataModelExtendsRule.create(mockContext);
+    expect(result.ClassDeclaration).toBeUndefined();
+  });
+
+  it('| should report when data-model class has no `extends`', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user.data-model.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'missingExtends') {
+          reportCalled = true;
+          expect(options.data.className).toBe('User_DataModel');
+        }
+      },
+      options: [],
+    };
+    const rule: any = dataModelExtendsRule.create(mockContext);
+    const mockNode: any = {
+      id: { name: 'User_DataModel' },
+      superClass: null,
+      body: { body: [] },
+    };
+    rule.ClassDeclaration(mockNode);
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should not report when extending DyFM_Metadata', () => {
+    let missingReported: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user.data-model.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'missingExtends') {
+          missingReported = true;
+        }
+      },
+      options: [],
+    };
+    const rule: any = dataModelExtendsRule.create(mockContext);
+    const mockNode: any = {
+      id: { name: 'User_DataModel' },
+      superClass: { type: 'Identifier', name: 'DyFM_Metadata' },
+      body: { body: [] },
+    };
+    rule.ClassDeclaration(mockNode);
+    expect(missingReported).toBe(false);
+  });
+
+  it('| should report parallel date field `createdAt`', () => {
+    let parallelReported: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user.data-model.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'parallelDateField') {
+          parallelReported = true;
+          expect(options.data.fieldName).toBe('createdAt');
+        }
+      },
+      options: [],
+    };
+    const rule: any = dataModelExtendsRule.create(mockContext);
+    const mockNode: any = {
+      id: { name: 'User_DataModel' },
+      superClass: { type: 'Identifier', name: 'DyFM_Metadata' },
+      body: {
+        body: [
+          { type: 'PropertyDefinition', key: { type: 'Identifier', name: 'createdAt' } },
+        ],
+      },
+    };
+    rule.ClassDeclaration(mockNode);
+    expect(parallelReported).toBe(true);
+  });
+});