How can I validate an update input type?

[matcic]

Hi,

given the following Prisma schema:

model User {
  ...
  email          String          @unique
  ...
}

I was able to easily add a validation rule to the email property by using this type enhancer:

const userInputTypesEnhancer: InputTypeConfig<"UserCreateInput"> = {
    fields: {
      email: [IsEmail()],
    },
  }

Now I would like to be able to add a similar validation rule to the UserUpdateInput type but the thing is this is the corresponding generated type:

class UserUpdateInput {
    ...
    email?: StringFieldUpdateOperationsInput | undefined;
    ...
}

where StringFieldUpdateOperationsInput is:

class StringFieldUpdateOperationsInput {
    set?: string | undefined;
}

Is there an easy way I can add a type enhancer only to the UserUpdateInput type?
My problem is that if I try to use the following:

const userInputTypesEnhancer: InputTypeConfig<"UserUpdateInput"> = {
    fields: {
      email: [IsEmail()],
    },
  }

then what I am effectively decorating/validating is StringFieldUpdateOperationsInput, which of course is not what I want.

Thanks in advance!

[MichalLytek]

typegraphql-prisma was always meant to be a source code generator, not a "DB into GraphQL API" converter/layer.
Adding decorators to types is just a workaround for those who want to add validation/other stuff without ejecting from the generator flow.

There's no solution for that and I can't imagine any for now. That two approaches just doesn't match together.
With code first approach #9 you would need to write the input classes by yourself, in order to modify them and add a decorator.

[Nickesh]

I fully agree with it. With all the power that "typegraphql-prisma" brings to the process of creating typed, fast and precise GraphQL APIs this small flaw makes them unsafe.

[MichalLytek]

@matcic Basically it's a limitation of class-validator that it cannot validate in a broader context, only the leaves of the trees.
Prisma's input shape is nested, like you can set, increment and do other operation on fields.
Users would like to control also those aspect, so that they can allow to increment/decrement only by 1, while allow to set to 0.

Until we figure it out, I think I will create a generator option to bring back non-nested inputs that are easier to validate.
Because not everyone needs full power of Prisma exposed in GraphQL 😉

#221

[kamaridesu]

@MichalLytek So for people who are still new to all this technologies and super advanced knowleadge like myself, how could a person using this package be able to validate the inputs,

[Nickesh]

@kamaridesu, you can create your own resolvers. Which is actually what you should have done anyway, according to the intention of this library (it's not meant to be used for creating the final production solutions in this aspect).

However, there are still many shortcuts. You can copy the automatically-generated resolvers to your own source code and then simply adjust them (you don't have to creaste everything from scratch). You can even automate it somehow, using some script or additional JS code, playing with Reflections, or even try to create your own generator (or fork the original one).

In my own project the majority of the requests were queries - only a few mutations. So I only had to recreate a limited number of resolvers. I simply created my own ArgTypes, reusing the original ones and then decorated all nesting args with @ValidateNested().

I'll fix it in the future when @MichalLytek finds the way to solve this issue internally in his library. But even without that fix, TypeGraphQL remains a bloody brilliant piece of art. Thanks million for creating and sharing it with us, Michał!

[FRSgit]

For the future travelers:

I've come up with a solution that allows to apply additional decorators on entity's update input type.

So, the main thing is that I've created an additional class-validator-compatible validator. It creates a "fake" class (function) which is then decorated and provided to validate method. All of the errors raised by class-validator are stored and used as a result of the validator:

import { __decorate } from 'tslib';
import { plainToInstance, type ClassConstructor } from 'class-transformer';
import {
  registerDecorator,
  type ValidationOptions,
  validate,
  type ValidationError,
} from 'class-validator';

export function ValidateProperty(
  property: string,
  decorators: PropertyDecorator | PropertyDecorator[],
  validationOptions?: ValidationOptions,
) {
  return function (object: unknown, propertyName: string) {
    let errorMsgs: ValidationError[] = [];

    const ValidationCls = function () {} as unknown as ClassConstructor<object>;

    __decorate(
      Array.isArray(decorators) ? decorators : [decorators],
      ValidationCls.prototype,
      property,
    );

    registerDecorator({
      name: 'validateProperty',
      target: object.constructor,
      propertyName: propertyName,
      constraints: [],
      options: validationOptions,
      validator: {
        async validate(value: unknown) {
          errorMsgs = [];
          errorMsgs = await validate(plainToInstance(ValidationCls, value));
          return !errorMsgs.length;
        },
        defaultMessage({ property }) {
          return `${property}: ${errorMsgs
            .reduce(
              (acc, { constraints }) => acc.concat(Object.values(constraints)),
              [],
            )
            .toString()}`;
        },
      },
    });
  };
}

And now, to use it:

import {
  applyArgsTypesEnhanceMap,
  applyInputTypesEnhanceMap,
} from '@generated/type-graphql/enhance';
import {
  ValidateNested,
  Allow,
  MaxLength
} from 'class-validator';

applyArgsTypesEnhanceMap({
  CreateOneGroupArgs: {
    fields: {
      data: [ValidateNested()],
    },
  },
  UpdateOneGroupArgs: {
    fields: {
      data: [ValidateNested()],
    },
  },
});

applyInputTypesEnhanceMap({
  // for create input type
  GroupUncheckedCreateInput: {
    fields: {
      _all: [Allow()],
      slug: [MaxLength(20)],
    },
  },
  // and for update input type
  GroupUncheckedUpdateInput: {
    fields: {
      _all: [Allow()],
      // important, as TypeGraphQL generates update inputType for a field in form of an object like: { set: string }
      slug: [ValidateProperty('set', [MaxLength(20)])],
    },
  },
});

Hope that helps someone :)