fix: sync ESLint and Prettier configurations

- Install eslint-config-prettier to disable conflicting ESLint formatting rules
- Remove formatting rules from ESLint (semi, quotes, comma-dangle, etc.)
  as Prettier handles all formatting
- Keep code quality rules in ESLint (eqeqeq, curly, no-var, etc.)
- Format and lint now work together without conflicts

This ensures that running 'npm run format' followed by 'npm run lint'
will always pass, and vice versa.

Author: lupu60

eslint.config.js

@@ -2,10 +2,12 @@ import js from '@eslint/js';
 import tseslint from 'typescript-eslint';
 import importPlugin from 'eslint-plugin-import';
 import promisePlugin from 'eslint-plugin-promise';
+import prettierConfig from 'eslint-config-prettier';
 
 export default tseslint.config(
   js.configs.recommended,
   ...tseslint.configs.recommended,
+  prettierConfig,
   {
     files: ['**/*.ts'],
     languageOptions: {
@@ -20,33 +22,20 @@ export default tseslint.config(
       promise: promisePlugin
     },
     rules: {
-      // Standard.js style rules
-      'semi': ['error', 'always'],
-      'quotes': ['error', 'single'],
-      'comma-dangle': ['error', 'never'],
-      'space-before-function-paren': ['error', {
-        'anonymous': 'always',
-        'named': 'never',
-        'asyncArrow': 'always'
-      }],
-      'no-trailing-spaces': 'error',
-      'eol-last': ['error', 'always'],
-      'no-multiple-empty-lines': ['error', { 'max': 2, 'maxEOF': 1 }],
-      'padded-blocks': ['error', 'never'],
-      'brace-style': ['error', '1tbs', { 'allowSingleLine': true }],
+      // Code quality rules (formatting handled by Prettier)
       'camelcase': ['error', { 
         'properties': 'never', 
         'ignoreDestructuring': true, 
         'allow': ['^_upsert_status$', '^_[a-z_]+$', '^[a-z]+_[a-z_]+$'] 
       }],
+      // Code quality rules
       'no-control-regex': 'off',
       'curly': ['error', 'all'],
       'eqeqeq': ['error', 'always'],
       'no-throw-literal': 'error',
       'no-var': 'error',
       'prefer-const': 'error',
       'prefer-arrow-callback': 'error',
-      'arrow-spacing': ['error', { 'before': true, 'after': true }],
       'no-unused-vars': 'off',
       '@typescript-eslint/no-unused-vars': ['error', {
         'argsIgnorePattern': '^_',

package-lock.json

@@ -57,6 +57,7 @@
     "@typescript-eslint/eslint-plugin": "^8.54.0",
     "@typescript-eslint/parser": "^8.54.0",
     "eslint": "9.29.0",
+    "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "2.32.0",
     "eslint-plugin-n": "17.20.0",
     "eslint-plugin-promise": "7.2.1",

package.json

@@ -36,15 +36,15 @@ export class AccessControlModule {
       providers: [
         {
           provide: RULES_BUILDER_TOKEN,
-          useValue: rules
-        }
+          useValue: rules,
+        },
       ],
       exports: [
         {
           provide: RULES_BUILDER_TOKEN,
-          useValue: rules
-        }
-      ]
+          useValue: rules,
+        },
+      ],
     };
   }
 
@@ -55,26 +55,26 @@ export class AccessControlModule {
     if (useExisting) {
       provider = {
         provide: RULES_BUILDER_TOKEN,
-        useExisting
+        useExisting,
       };
     } else if (useClass) {
       provider = {
         provide: RULES_BUILDER_TOKEN,
-        useClass
+        useClass,
       };
     } else {
       provider = {
         provide: RULES_BUILDER_TOKEN,
         useFactory: useFactory || (() => new RulesBuilder()),
-        inject
+        inject,
       };
     }
 
     return {
       module: AccessControlModule,
       imports,
       providers: [provider],
-      exports: [provider]
+      exports: [provider],
     };
   }
 }

packages/access-control/src/access-control.module.ts

@@ -11,9 +11,9 @@ describe('forRootAsync', () => {
     const module: TestingModule = await Test.createTestingModule({
       imports: [
         AccessControlModule.forRootAsync({
-          useFactory: (): RulesBuilder => new RulesBuilder()
-        })
-      ]
+          useFactory: (): RulesBuilder => new RulesBuilder(),
+        }),
+      ],
     }).compile();
 
     const rules = module.get(RULES_BUILDER_TOKEN);
@@ -28,9 +28,9 @@ describe('forRootAsync', () => {
           useFactory: async (): Promise<RulesBuilder> => {
             await delay(100);
             return new RulesBuilder();
-          }
-        })
-      ]
+          },
+        }),
+      ],
     }).compile();
 
     const rules = module.get(RULES_BUILDER_TOKEN);
@@ -45,7 +45,7 @@ describe('forRoles', () => {
     const options: ACOptions = { grantsEndpoint: 'grants' };
 
     const module: TestingModule = await Test.createTestingModule({
-      imports: [AccessControlModule.forRules(rules, options)]
+      imports: [AccessControlModule.forRules(rules, options)],
     }).compile();
 
     const controller = module.get<GrantsController>(GrantsController);
@@ -59,7 +59,7 @@ describe('forRoles', () => {
     const options: ACOptions = {};
 
     const module: TestingModule = await Test.createTestingModule({
-      imports: [AccessControlModule.forRules(rules, options)]
+      imports: [AccessControlModule.forRules(rules, options)],
     }).compile();
 
     expect(() => {
@@ -71,7 +71,7 @@ describe('forRoles', () => {
     const rules: RulesBuilder = new RulesBuilder();
 
     const module: TestingModule = await Test.createTestingModule({
-      imports: [AccessControlModule.forRules(rules)]
+      imports: [AccessControlModule.forRules(rules)],
     }).compile();
 
     expect(() => {

packages/access-control/src/access.control.module.spec.ts

@@ -16,9 +16,9 @@ describe('Grants Controller #getGrants', () => {
       providers: [
         {
           provide: RULES_BUILDER_TOKEN,
-          useValue: roles
-        }
-      ]
+          useValue: roles,
+        },
+      ],
     }).compile();
 
     controller = module.get<GrantsController>(GrantsController);

packages/access-control/src/controller/grants.controller.spec.ts

@@ -7,8 +7,8 @@ describe('BootstrapLog', () => {
       hostname: 'localhost',
       package_json_body: {
         name: 'test',
-        version: '1.0.0'
-      }
+        version: '1.0.0',
+      },
     };
     BootstrapLog({ config });
   });
@@ -19,13 +19,13 @@ describe('BootstrapLog', () => {
       hostname: 'localhost',
       package_json_body: {
         name: 'test',
-        version: '1.0.0'
+        version: '1.0.0',
       },
       redis_url: 'redis://localhost:6379',
       database_url: 'postgres://localhost:5432/test',
       sentry: true,
       health_check: true,
-      swagger: true
+      swagger: true,
     };
     BootstrapLog({ config });
   });

packages/bootstrap-log/src/test/bootstrap-log.spec.ts

@@ -16,7 +16,9 @@ export class BunyanLoggerService implements LoggerService {
   private readonly formatterOptions: FormatterOptions;
   private readonly maxLength?: number;
   private isEmpty = (obj: unknown): boolean => {
-    if (!obj || typeof obj !== 'object') {return false;}
+    if (!obj || typeof obj !== 'object') {
+      return false;
+    }
     const constructorName = (obj as object).constructor?.name;
     return (constructorName === 'Object' || constructorName === 'Array') && !Object.entries(obj).length;
   };
@@ -56,7 +58,7 @@ export class BunyanLoggerService implements LoggerService {
       level: Bunyan.INFO,
       name: projectId,
       streams: [...streams],
-      ...extraFields
+      ...extraFields,
     });
   }
 
@@ -135,7 +137,7 @@ export class BunyanLoggerService implements LoggerService {
     if (typeof processedMessage === 'string' && optionalParams.length > 0) {
       const interpolationObject = optionalParams.find(
         (param): param is Record<string, unknown> =>
-          param !== null && typeof param === 'object' && !Array.isArray(param) && !(param instanceof Error)
+          param !== null && typeof param === 'object' && !Array.isArray(param) && !(param instanceof Error),
       );
       if (interpolationObject) {
         processedMessage = this.interpolateString(processedMessage, interpolationObject);
@@ -206,7 +208,7 @@ export class BunyanLoggerService implements LoggerService {
       const nonStringParams = optionalParams.filter((param) => param !== trace && param !== context);
       const interpolationObject = nonStringParams.find(
         (param): param is Record<string, unknown> =>
-          param !== null && typeof param === 'object' && !Array.isArray(param) && !(param instanceof Error)
+          param !== null && typeof param === 'object' && !Array.isArray(param) && !(param instanceof Error),
       );
       if (interpolationObject) {
         processedMessage = this.interpolateString(processedMessage, interpolationObject);