A value resolver for MapWithArguments transformation to forward some value from extraArguments object

[micalevisk]

I've made a value resolver for mapWithArguments that just forwards values passed to extraArguments object.

You can use this makeExtraArgsPropForwardingResolver factory passing the name of the property that you want to look up in extraArguments.

You can use it like this (in TypeScript):

class FooDto {
  bar: number
}
// ...
type ExtraArgs = { bar: number }

mapper
.createMap(Foo, FooDto)
// You could use like this:
.forMember(
  (d) => d.bar,
  mapWithArguments(
    makeExtraArgsPropForwardingResolver<ExtraArgs, FooDto['bar']>('bar'),
    //                                  \_______/   \_________/
    //                                      |            |
    //                                      |            |
    //                                      |  Destination type that must match with ExtraArgs['bar'] type
    //                                      |
    //                                      |
    //  To prevent (in complie time) from passing strings above that won't be passed to extraArguments
  ),
// or like this:
.forMember(
  (d) => d.bar,
  forwardingExtraArgs<ExtraArgs, FooDto['bar']>('bar')
 )
)

// ...
mapper.map(foo, FooDto, Foo, { extraArguments: { bar: 123 } }

My solution: make-extra-args-prop-forwarding-resolver.ts file

/** */
type KeysWhereValuesAre<O extends Record<string, any>, T> = {
  [key in keyof O]: O[key] extends T ? key : never;
}[keyof O];

import type { Resolver } from '@automapper/types';

/**
 * A factory for an AutoMapper value resolver for **MapWithArguments** that
 * just forwards the value of the given property `extraArgsPropToLookup` that
 * should be passed while doing some mapping operation, when you don't care about
 * the source object.
 *
 * The resolver will throw an error for the following cases:
 * - `Error` if there is no extra arguments given to the `Mapper#map` operation.
 * - `Error` if the `extraArgsPropToLookup` is not in the given extra arguments.
 *
 * For instance, if you create a mapping like the following:
 *
 * ```ts
 * type ExtraArgs = { myProp: number }
 *
 * mapper.createMap(Foo, FooDto)
 *   .forMember(d => d.bar)
 *   .mapWithArguments(makeExtraArgsPropForwardingResolver<ExtraArgs, FooDto['bar']>('myProp'))
 * ```
 *
 * You might end up using it like this:
 *
 * ```js
 * mapper.map(foo, FooDto, Foo, {
 *   extraArguments: {
 *     myProp: 123
 *   }
 * })
 * ```
 * then the value of `bar` in object returned above will be `number` `123`.
 *
 * Read more about `MapWithArguments` value resolver here:
 * {@link https://automapperts.netlify.app/docs/mapping-configuration/map-with-arguments}
 */
export const makeExtraArgsPropForwardingResolver = <
  TExtraArgs extends Record<string, unknown>,
  TSelectorReturn = unknown,
>(
  extraArgsPropToLookUp: KeysWhereValuesAre<TExtraArgs, TSelectorReturn>,
): Resolver<any, TExtraArgs, TSelectorReturn> => {
  const extraArgsPropForwardingResolver: Resolver<any, TExtraArgs, TSelectorReturn> = {
    /**
     * @throws {Error} If there is no extra arguments.
     * @throws {Error} If the given property to look up does not exist in the
     * extra arguments object.
     */
    resolve(_, extraArgs) {
      if (extraArgs === undefined) {
        throw new Error('The extra arguments was not given to the mapper!');
      }

      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
      // @ts-expect-error Left-hand side must be of type 'any', 'string', 'number', or 'symbol'
      if (extraArgsPropToLookUp in extraArgs) {
        // We could do the following type assertion since TSC will make sure that
        // `extraArgs[extraArgsPropToLookUp]` is in fact of the same type of
        // `TDestination` through compiler errors if they doesn't match
        return extraArgs[extraArgsPropToLookUp] as TSelectorReturn;
      }

      throw new Error(
        `The given extra arguments has no "${extraArgsPropToLookUp.toString()}" field!`,
      );
    },
  };

  return extraArgsPropForwardingResolver;
};

import { mapWithArguments } from '@automapper/core';
import type { MapWithArgumentsReturn } from '@automapper/types';

/** */
export function forwardingExtraArgs<
  TExtraArgs extends Record<string, unknown>,
  TSelectorReturn = unknown,
>(
  extraArgsPropToLookup: KeysWhereValuesAre<TExtraArgs, TSelectorReturn>,
): MapWithArgumentsReturn<any, any, TSelectorReturn> {
  return mapWithArguments(
    makeExtraArgsPropForwardingResolver<TExtraArgs, TSelectorReturn>(extraArgsPropToLookup),
  );
}

---

If someone could improve this somehow or have another solution, share with me, please! :)

[micalevisk]

EDIT:

nvm '-' I got it now.

---

btw @nartc do you think that the second type arg of my makeExtraArgsPropForwardingResolver could be inferred like the mapFrom operator?

It would be better if I could use it like this:

    makeExtraArgsPropForwardingResolver<ExtraArgs>('bar'),

tbh I'm using TS for while but I'm still trying to understand how do you manage to let mapFrom (and others) infer the destination type properly lol

[micalevisk]

cool! ty

[nartc]

function forwardingExtraArgs<
  TSource extends Dictionary<TSource> = any,
  TDestination extends Dictionary<TDestination> = any,
  TSelectorReturn = SelectorReturn<TDestination>
>(key: string): MapWithArgumentsReturn<TSource, TDestination, TSelectorReturn> {
  return mapWithArguments<TSource, TDestination, TSelectorReturn>(
    (_, extraArgs) => {
      return extraArgs[key] as TSelectorReturn;
    }
  );
}

I'd remove TExtraArgs as with it, the type inference is messed up :D Since your implementation throws error for invalid key anyway

[nartc]

[micalevisk]

I end up with this approach:

import { mapWithArguments } from '@automapper/core';
import type { MapWithArgumentsReturn } from '@automapper/types';

/**
 * `KeysWhereValuesAre<O, T>`
 *
 * From `O` object-like, return an uninon of all the keys there are assignable
 * to `T`, `never` otherwise.
 */
type KeysWhereValuesAre<O extends Record<string, any>, T> = {
  [key in keyof O]: O[key] extends T ? key : never;
}[keyof O];

/**
 * A custom **transformation type** for `@automapper` lib. You could use this if
 * you want to just forward some property that will be passed as a extra arguments
 * to your map operation.
 *
 * The **MapWithArguments** will throw an error for the following cases:
 * - `Error` if there is no extra arguments given to the `Mapper#map` operation.
 * - `Error` if the `extraArgsPropToLookup` is not in the given extra arguments.
 * For instance, if you create a mapping like the following:
 *
 * ```ts
 * type ExtraArgs = { myProp: number }
 *
 * mapper.createMap(Foo, FooDto)
 *   .forMember(destination => destination.bar)
 *   .forwardingExtraArgs<ExtraArgs, FooDto['bar']>('myProp')
 * ```
 *
 * You might end up using it like this:
 *
 * ```js
 * mapper.map(foo, FooDto, Foo, {
 *   extraArguments: <ExtraArgs>{
 *     myProp: 123
 *   }
 * })
 * ```
 *
 * Notice that if your give the type for extra args object, then you must give
 * the return type of your selector, make your mapping configuration type-safe.
 * This is a limitation since there is no way to infer the `TSelectorReturn`
 * properly. See: {@link https://github.com/nartc/mapper/discussions/344}
 *
 * Read more about `MapWithArguments` value resolver here:
 * {@link https://automapperts.netlify.app/docs/mapping-configuration/map-with-arguments}
 */
export function forwardingExtraArgs<
  //
  TExtraArgs extends Record<string, any>,
  TSelectorReturn,
>(
  extraArgsPropToLookup: KeysWhereValuesAre<TExtraArgs, TSelectorReturn> extends string
    ? KeysWhereValuesAre<TExtraArgs, TSelectorReturn>
    : never,
): MapWithArgumentsReturn<any, TSelectorReturn, TSelectorReturn> {
  return mapWithArguments(
    (_, givenExtraArgs: TExtraArgs) => {
      if (givenExtraArgs === undefined) {
        throw new Error('The extra arguments was not given to the mapper!');
      }

      if (extraArgsPropToLookup in givenExtraArgs) {
        return givenExtraArgs[extraArgsPropToLookup];
      }

      throw new Error(
        `The extra arguments given to the mapping operation has no "${extraArgsPropToLookup.toString()}" property!`,
      );
    },
  );
}

Because I really want it to check at compile that if the type of key matches with TSelectorReturn, thus I need to pass the TExtraArgs

unfortunately looks like there's no way to infer the TSelectorReturn in my solution :/

---

btw I think it would be nice if we could pass the type of extraArguments

mapper/packages/core/src/lib/map/map-member.ts

Line 30 in b1ff198

extraArguments: Record<string, unknown> | undefined,

// instead of using type assertions like
mapper.map(..., {
  extraArguments: <ExtraArgs>{
    institutionOwner: institutionId
  }
})
// could be this, but it breaks the pattern adopted for `@AutoMapper`'s API
// so I don't think this approach is feasible :p
mapper.map<ExtraArgs>(..., {
  extraArguments: {
    institutionOwner: institutionId
  }
})

[nartc]

Yeah, messing with those types require a lot of effort xD