chore: lint custom ts/no-arrow-parameter-types

Author: Shinigami92

eslint.config.ts

@@ -42,6 +42,7 @@ export default defineConfig(
   {
     name: 'eslint overrides',
     rules: {
+      curly: ['error', 'all'],
       eqeqeq: ['error', 'always', { null: 'ignore' }],
       'logical-assignment-operators': 'error',
       'no-else-return': 'error',
@@ -265,6 +266,127 @@ export default defineConfig(
       '@typescript-eslint/no-throw-literal': 'off',
       'unicorn/no-array-reduce': 'off',
     },
-  }
+  },
   //#endregion
+
+  {
+    name: 'custom',
+    plugins: {
+      custom: {
+        rules: {
+          'no-arrow-parameter-types': {
+            meta: {
+              fixable: 'code',
+              hasSuggestions: true,
+              type: 'suggestion',
+              dialects: ['typescript'],
+              schema: [
+                {
+                  type: 'object',
+                  properties: {
+                    allowOptional: {
+                      type: 'boolean',
+                      default: false,
+                      description:
+                        'Allow type annotations when the parameter is optional. Sometimes useful for overloaded functions.',
+                    },
+                  },
+                },
+              ],
+              defaultOptions: [
+                {
+                  allowOptional: false,
+                },
+              ],
+            },
+            create(context) {
+              const options = context.options[0] as { allowOptional: boolean };
+
+              return {
+                ArrowFunctionExpression(node) {
+                  const paramsWithTypeAnnotation = node.params.filter(
+                    (
+                      // @ts-expect-error: will be inferred when moved into an official plugin
+                      param
+                    ) => param.typeAnnotation !== undefined
+                  );
+
+                  const isCatchClause =
+                    node.parent.callee?.property?.name === 'catch';
+
+                  if (paramsWithTypeAnnotation.length > 0 && !isCatchClause) {
+                    for (const param of paramsWithTypeAnnotation) {
+                      if (param.optional && options.allowOptional) {
+                        continue;
+                      }
+
+                      context.report({
+                        node: param,
+                        message:
+                          'Arrow function parameters should not have type annotations. Instead the Object where the operation is used should be typed correctly.',
+                        fix(fixer) {
+                          if (param.optional) {
+                            return null;
+                          }
+
+                          // TODO @Shinigami92 2025-06-16: Handle async arrow functions
+                          if (node.parent.type === 'VariableDeclarator') {
+                            const variableDeclaratorNode = node.parent;
+
+                            return [
+                              // Remove ` =>`
+                              fixer.replaceTextRange(
+                                [node.body.range[0] - 3, node.body.range[0]],
+                                ''
+                              ),
+                              // Remove ` = `
+                              fixer.replaceTextRange(
+                                [
+                                  variableDeclaratorNode.id.range[1],
+                                  variableDeclaratorNode.init.range[0],
+                                ],
+                                ''
+                              ),
+                              // Replace `const ` with `function `
+                              fixer.replaceTextRange(
+                                [
+                                  variableDeclaratorNode.parent.range[0],
+                                  variableDeclaratorNode.range[0],
+                                ],
+                                'function '
+                              ),
+                            ];
+                          }
+
+                          return fixer.removeRange(param.typeAnnotation.range);
+                        },
+                        suggest: [
+                          {
+                            desc: 'Remove type annotation',
+                            fix(fixer) {
+                              if (param.optional) {
+                                return fixer.removeRange([
+                                  param.typeAnnotation.range[0] - 1, // Remove the `?` before the type annotation
+                                  param.typeAnnotation.range[1],
+                                ]);
+                              }
+
+                              return null;
+                            },
+                          },
+                        ],
+                      });
+                    }
+                  }
+                },
+              };
+            },
+          },
+        },
+      },
+    },
+    rules: {
+      'custom/no-arrow-parameter-types': ['error', { allowOptional: true }],
+    },
+  }
 );

src/db.ts

@@ -106,7 +106,7 @@ export function db(
     });
 
   const query: DBConnection['query'] = async (
-    queryTextOrConfig: string | QueryConfig | QueryArrayConfig,
+    queryTextOrConfig,
     values?: any[]
   ): Promise<QueryArrayResult | QueryResult> => {
     await createConnection();
@@ -147,20 +147,23 @@ ${error}
   };
 
   const select: DBConnection['select'] = async (
-    queryTextOrConfig: string | QueryConfig | QueryArrayConfig,
+    queryTextOrConfig,
     values?: any[]
   ) => {
     const { rows } = await query(queryTextOrConfig, values);
     return rows;
   };
 
   const column: DBConnection['column'] = async (
-    columnName: string,
-    queryTextOrConfig: string | QueryConfig | QueryArrayConfig,
+    columnName,
+    queryTextOrConfig,
     values?: any[]
   ) => {
-    const rows = await select(queryTextOrConfig, values);
-    return rows.map((r: { [key: string]: any }) => r[columnName]);
+    const rows: Array<{ [key: string]: any }> = await select(
+      queryTextOrConfig,
+      values
+    );
+    return rows.map((r) => r[columnName]);
   };
 
   return {

src/migrationBuilder.ts

@@ -825,9 +825,11 @@ export class MigrationBuilder {
     // This function wraps each operation within a function that either calls
     // the operation or its reverse, and appends the result
     // (array of sql statements) to the steps array
-    const wrap =
-      <TOperation extends Operation>(operation: TOperation) =>
-      (...args: Parameters<TOperation>) => {
+    const wrap: <TOperation extends Operation>(
+      operation: TOperation
+    ) => (...args: Parameters<TOperation>) => void =
+      (operation) =>
+      (...args) => {
         if (this._REVERSE_MODE) {
           if (typeof operation.reverse !== 'function') {
             const name = `pgm.${operation.name}()`;
@@ -970,9 +972,11 @@ export class MigrationBuilder {
 
     // Expose DB so we can access database within transaction
     /* eslint-disable @typescript-eslint/no-explicit-any */
-    const wrapDB =
-      <T extends any[], TResult>(operation: (...args: T) => TResult) =>
-      (...args: T) => {
+    const wrapDB: <T extends any[], TResult>(
+      operation: (...args: T) => TResult
+    ) => (...args: T) => TResult =
+      (operation) =>
+      (...args) => {
         if (this._REVERSE_MODE) {
           throw new Error('Impossible to automatically infer down migration');
         }

src/operations/operators/addToOperatorFamily.ts

@@ -12,9 +12,9 @@ export type AddToOperatorFamilyFn = (
 
 export type AddToOperatorFamily = Reversible<AddToOperatorFamilyFn>;
 
-export const addToOperatorFamily = (
+export const addToOperatorFamily: (
   mOptions: MigrationOptions
-): AddToOperatorFamily => {
+) => AddToOperatorFamily = (mOptions) => {
   const method: AddToOperatorFamily = (
     operatorFamilyName,
     indexMethod,

src/operations/operators/removeFromOperatorFamily.ts

@@ -9,9 +9,9 @@ export type RemoveFromOperatorFamily = (
   operatorList: OperatorListDefinition[]
 ) => string;
 
-export const removeFromOperatorFamily = (
+export const removeFromOperatorFamily: (
   mOptions: MigrationOptions
-): RemoveFromOperatorFamily => {
+) => RemoveFromOperatorFamily = (mOptions) => {
   const method: RemoveFromOperatorFamily = (
     operatorFamilyName,
     indexMethod,

src/operations/schemas/createSchema.ts

@@ -15,7 +15,7 @@ export type CreateSchemaFn = (
 export type CreateSchema = Reversible<CreateSchemaFn>;
 
 export function createSchema(mOptions: MigrationOptions): CreateSchema {
-  const _create: CreateSchema = (schemaName: string, options = {}) => {
+  const _create: CreateSchema = (schemaName, options = {}) => {
     const { ifNotExists = false, authorization } = options;
 
     const ifNotExistsStr = ifNotExists ? ' IF NOT EXISTS' : '';

src/operations/tables/shared.ts

@@ -439,10 +439,10 @@ export function parseLike(
   like: Name | { table: Name; options?: LikeOptions },
   literal: Literal
 ): string {
-  const formatOptions = (
+  const formatOptions: (
     name: 'INCLUDING' | 'EXCLUDING',
     options?: Like | Like[]
-  ) =>
+  ) => string = (name, options) =>
     toArray(options)
       .filter((option): option is Like => option !== undefined)
       .map((option) => ` ${name} ${option}`)

src/operations/triggers/createTrigger.ts

@@ -26,12 +26,14 @@ export type CreateTrigger = Reversible<CreateTriggerFn>;
 
 export function createTrigger(mOptions: MigrationOptions): CreateTrigger {
   const _create: CreateTrigger = (
+    /* eslint-disable custom/no-arrow-parameter-types */
     tableName: Name,
     triggerName: string,
     triggerOptions:
       | (TriggerOptions & DropOptions)
       | (TriggerOptions & FunctionOptions & DropOptions),
     definition?: Value
+    /* eslint-enable custom/no-arrow-parameter-types */
   ) => {
     const {
       constraint = false,

test/ts/customRunner.ts

@@ -13,7 +13,7 @@ type Options =
   | ({ databaseUrl: string } & TestOptions)
   | ({ dbClient: Client } & TestOptions);
 
-export const run = async (options: Options): Promise<boolean> => {
+export const run: (options: Options) => Promise<boolean> = async (options) => {
   const opts: Omit<RunnerOption, 'direction'> & Options = {
     migrationsTable: 'migrations',
     dir: resolve(import.meta.dirname, 'migrations'),