Transforming input fields

[MatthiasKunnen]

I find myself short of an easy way to perform reusable transformation on input fields.

Say there is the following input object:

export const AddressInputType = new GraphQLInputObjectType({
    name: 'AddressInput',
    fields: () => ({
        name: {
            type: new GraphQLNonNull(GraphQLString),
        },
    }),
});

I would like to be able to do the following:

export const trim = (source, info) => source[info.fieldName].trim();
export const toUpperCase = (source, info) => source[info.fieldName].toUpperCase();

export const AddressInputType = new GraphQLInputObjectType({
    name: 'AddressInput',
    fields: () => ({
        name: {
            type: new GraphQLNonNull(GraphQLString),
            transform: [
                trim,
                toUpperCase,
            ],
        },
    }),
});

Returning undefined from a transform function should remove the field from the source object.

When to transform? I believe the transformation should occur after the type is parsed although arguments can be made to apply the transform before parsing. A potential solution is to have a transformBefore and a transformAfter property.

It should be possible to throw an error in the transform function. This should be handled similar to throwing an error in the type parser.

[langpavel]

Uff, why transform?

1. You can call what you want in resolver
2. You can create your own GraphQLScalarType which can transform everything to something other
   See https://graphql.org/graphql-js/type/#graphqlscalartype:

type GraphQLScalarTypeConfig<TInternal, TExternal> = {
  name: string;
  description?: ?string;
  serialize: (value: mixed) => ?TExternal; // ← There is bug in documentation, TExternal is correct
  parseValue?: (value: mixed) => ?TInternal;
  parseLiteral?: (valueAST: Value) => ?TInternal;
}

😬 hih, there is bug in docs, above is correct, extracted from source code :-)

For example, entire GraphQLString implementation:

function serializeString(rawValue: mixed): string {
  const value = serializeObject(rawValue);

  // Serialize string, boolean and number values to a string, but do not
  // attempt to coerce object, function, symbol, or other types as strings.
  if (typeof value === 'string') {
    return value;
  }
  if (typeof value === 'boolean') {
    return value ? 'true' : 'false';
  }
  if (isFinite(value)) {
    return value.toString();
  }
  throw new TypeError(`String cannot represent value: ${inspect(rawValue)}`);
}

function coerceString(value: mixed): string {
  if (typeof value !== 'string') {
    throw new TypeError(
      `String cannot represent a non string value: ${inspect(value)}`,
    );
  }
  return value;
}

export const GraphQLString = new GraphQLScalarType({
  name: 'String',
  description:
    'The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.',
  serialize: serializeString,
  parseValue: coerceString,
  parseLiteral(ast) {
    return ast.kind === Kind.STRING ? ast.value : undefined;
  },
});

[MatthiasKunnen]

I know you can make a type for some of the use cases, but they are limited in re-usability. If I want to both trim and uppercase an incoming string I would need to make a specific type for that. For trim and lowercase the same, ... It does not scale. It also makes the consumer of the API have to change their types in queries and mutations.

There are scenarios in which I don't want to change the type but I want to be able to apply transformations without writing a bunch of code in resolvers.

[MichalLytek]

@MatthiasKunnen
Are directives the feature you want? You can place @uppercase and @trim near the field declaration and the schema visitor will apply the transformation in runtime 😕

Or we're not able to apply custom resolve logic for INPUT_FIELD in directives?

EDIT: Yup, there's no resolve feature but you can use directives on input fields to transform the type to custom scalar and then pass the metadata to its constructor to apply some transformation in parseValue or parseLiteral 😉

[MatthiasKunnen]

I checked out directives and while they don't work the same as this proposal, they seem to be able to accomplish what I want. I'll close this issue.

[MichalLytek]

For future readers - example here 😉
https://github.com/confuser/graphql-constraint-directive/blob/master/index.js