- Rename functionality separated from CustomValidation

- Wildcard support
- Test cases added for wildcard and non-wildcard field rename

src/chain/validators-impl.ts

@@ -1,17 +1,17 @@
 import * as validator from 'validator';
 import { CustomValidator, StandardValidator } from '../base';
-import { CustomValidation, StandardValidation } from '../context-items';
+import { CustomValidation, RenameFieldContextItem, StandardValidation } from '../context-items';
 import { ContextBuilder } from '../context-builder';
 import * as Options from '../options';
 import { Validators } from './validators';
 
 export class ValidatorsImpl<Chain> implements Validators<Chain> {
-  private lastValidator: CustomValidation | StandardValidation;
+  private lastValidator: CustomValidation | RenameFieldContextItem | StandardValidation;
   private negateNext = false;
 
   constructor(private readonly builder: ContextBuilder, private readonly chain: Chain) {}
 
-  private addItem(item: CustomValidation | StandardValidation) {
+  private addItem(item: CustomValidation | RenameFieldContextItem | StandardValidation) {
     this.builder.addItem(item);
     this.lastValidator = item;
     // Reset this.negateNext so that next validation isn't negated too
@@ -36,6 +36,10 @@ export class ValidatorsImpl<Chain> implements Validators<Chain> {
     return this.addItem(new CustomValidation(validator, this.negateNext));
   }
 
+  rename(evaluator: CustomValidator) {
+    return this.addItem(new RenameFieldContextItem(evaluator, this.negateNext));
+  }
+
   exists(options: { checkFalsy?: boolean; checkNull?: boolean } = {}) {
     let validator: CustomValidator;
     if (options.checkFalsy) {

src/chain/validators.ts

@@ -36,6 +36,14 @@ export interface Validators<Return> {
    */
   custom(validator: CustomValidator): Return;
 
+  /**
+   * Adds a field rename functionality to the validation chain.
+   *
+   * @param evaluator the custom evaluator based on the `CustomValidator`
+   * @returns the current validation chain
+   */
+  rename(evaluator: CustomValidator): Return;
+
   /**
    * Adds a validator to check that the fields exist in the request.
    * By default, this means that the value of the fields may not be `undefined`;

src/context-items/custom-validation.ts

@@ -19,10 +19,6 @@ export class CustomValidation implements ContextItem {
       if ((!isPromise && failed) || (isPromise && this.negated)) {
         context.addError(this.message, value, meta);
       }
-      // rename field if return type is string
-      if (typeof actualResult === 'string') {
-        context.renameFieldInstance(actualResult, meta);
-      }
     } catch (err) {
       if (this.negated) {
         return;

src/context-items/index.ts

@@ -3,3 +3,4 @@ export * from './context-item';
 export * from './custom-condition';
 export * from './custom-validation';
 export * from './standard-validation';
+export * from './rename-field';

src/context-items/rename-field.spec.ts

@@ -0,0 +1,121 @@
+import { Context } from '../context';
+import { ContextBuilder } from '../context-builder';
+import { Meta } from '../base';
+import { RenameFieldContextItem } from './rename-field';
+
+let context: Context;
+let validator: jest.Mock;
+let validation: RenameFieldContextItem;
+let meta: Meta;
+
+beforeEach(() => {
+  jest.spyOn(context, 'addError');
+  validator = jest.fn();
+});
+
+const createSyncTest = (options: { returnValue: any; isWildcard: boolean }) => async () => {
+  validator.mockReturnValue(options.returnValue);
+  await validation.run(context, options.returnValue, meta);
+  if (options.isWildcard) {
+    expect(context.getData()).toStrictEqual([
+      {
+        location: 'body',
+        path: 'bar.foo',
+        originalPath: 'foo.bar',
+        value: 'Hello World!',
+        originalValue: 123,
+      },
+    ]);
+  } else {
+    expect(context.getData()).toStrictEqual([
+      {
+        location: 'body',
+        path: 'bar',
+        originalPath: 'foo',
+        value: 'Hello World!',
+        originalValue: 123,
+      },
+    ]);
+  }
+};
+
+describe('Rename wildcard paths', () => {
+  beforeAll(() => {
+    meta = {
+      req: { body: { foo: { bar: 'foobar' } } },
+      location: 'body',
+      path: 'foo.bar',
+    };
+    context = new ContextBuilder().setFields(['foo.bar']).setLocations(['body']).build();
+  });
+  beforeEach(() => {
+    context.addFieldInstances([
+      {
+        location: 'body',
+        path: 'foo.bar',
+        originalPath: 'foo.bar',
+        value: 'Hello World!',
+        originalValue: 123,
+      },
+    ]);
+    validation = new RenameFieldContextItem(validator, false);
+    validation.message = 'nope';
+  });
+  it(
+    'Renames the field foo.bar to bar.foo',
+    createSyncTest({ returnValue: 'bar.foo', isWildcard: true }),
+  );
+  it('Renames the wildcard field with nested objects and arrays', async () => {
+    meta = {
+      req: { body: { bar: [{ foo: { end: 'Hello World!' } }] } },
+      location: 'body',
+      path: 'bar.*.foo.end',
+    };
+    context = new ContextBuilder().setFields(['bar.*.foo.end']).setLocations(['body']).build();
+    context.addFieldInstances([
+      {
+        location: 'body',
+        path: 'bar.*.foo.end',
+        originalPath: 'bar.*.foo.end',
+        value: 'Hello World!',
+        originalValue: 123,
+      },
+    ]);
+    validator.mockReturnValue('foo.*.bar.*.child.new_field');
+    await validation.run(context, 'foo.*.bar.*.child.new_field', meta);
+    expect(context.getData()).toStrictEqual([
+      {
+        location: 'body',
+        path: 'foo[0].bar[0].child.new_field',
+        originalPath: 'bar.*.foo.end',
+        value: 'Hello World!',
+        originalValue: 123,
+      },
+    ]);
+  });
+});
+
+describe('Rename non-wildcard fields', () => {
+  beforeAll(() => {
+    meta = {
+      req: { body: { foo: 'Hello World!' } },
+      location: 'body',
+      path: 'foo',
+    };
+    context = new ContextBuilder().setFields(['foo']).setLocations(['body']).build();
+  });
+  beforeEach(() => {
+    context.addFieldInstances([
+      {
+        location: 'body',
+        path: 'foo',
+        originalPath: 'foo',
+        value: 'Hello World!',
+        originalValue: 123,
+      },
+    ]);
+    validation = new RenameFieldContextItem(validator, false);
+    validation.message = 'nope';
+  });
+  it('Renames the field foo to bar', createSyncTest({ returnValue: 'bar', isWildcard: false }));
+});

src/context-items/rename-field.ts

@@ -0,0 +1,28 @@
+import { CustomValidator, Meta } from '../base';
+import { Context } from '../context';
+import { ContextItem } from './context-item';
+
+export class RenameFieldContextItem implements ContextItem {
+  message: any;
+
+  constructor(private readonly evaluator: CustomValidator, private readonly negated: boolean) {}
+
+  async run(context: Context, value: any, meta: Meta) {
+    try {
+      const result = this.evaluator(value, meta);
+      const actualResult = await result;
+      const isPromise = result && result.then;
+      const failed = this.negated ? actualResult : !actualResult;
+
+      // A promise that was resolved only adds an error if negated.
+      // Otherwise it always suceeds
+      if ((!isPromise && failed) || (isPromise && this.negated)) {
+        return;
+      }
+      // rename field if return type is string
+      if (typeof actualResult === 'string') {
+        context.renameFieldInstance(actualResult, meta);
+      }
+    } catch (err) {}
+  }
+}

src/context.ts

@@ -1,6 +1,7 @@
 import * as _ from 'lodash';
 import { FieldInstance, Location, Meta, ValidationError } from './base';
 import { ContextItem } from './context-items';
+import { fieldRenameUtility } from './utils';
 
 function getDataMapKey(path: string, location: Location) {
   return `${location}:${path}`;
@@ -117,7 +118,8 @@ export class Context {
       throw new Error('Attempt to rename multiple fields.');
     }
     if (/\.|\*/g.test(originalPath)) {
-      throw new Error('Attempt to rename a wildcard field');
+      instance.path = fieldRenameUtility(newPath, instance);
+      return;
     }
     instance.path = newPath;
   }

src/utils.ts

@@ -1,3 +1,5 @@
+import { FieldInstance } from './base';
+
 export const bindAll = <T>(object: T): { [K in keyof T]: T[K] } => {
   const protoKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(object)) as (keyof T)[];
   protoKeys.forEach(key => {
@@ -26,3 +28,27 @@ export function toString(value: any, deep = true): string {
 
   return String(value);
 }
+
+export function fieldRenameUtility(path: string, field: FieldInstance) {
+  if (path.includes('.*')) {
+    return _renameFieldWithAsterisk(path, field);
+  }
+  // Normal dot notation wildcard path
+  return path;
+}
+
+function _renameFieldWithAsterisk(path: string, field: FieldInstance) {
+  const { path: original } = field;
+  // Extract the indices from the input string
+  const regExp = /\[(\d+)\]/g;
+  const matches = [...original.matchAll(regExp)];
+  const indices = matches.map(([, index]) => index);
+
+  // Replace the placeholders in the format with the corresponding indices
+  let result = path;
+  result = result.replace(/\.\*/g, () => {
+    const _index = Number(indices.shift());
+    return !isNaN(_index) ? `[${_index}]` : '[0]';
+  });
+  return result;
+}