Merge pull request #3403 from SeedCompany/bugfix/null-inputs

Author: CarsonF

src/common/id-field.ts

@@ -1,16 +1,20 @@
 import { applyDecorators } from '@nestjs/common';
-import { Field, FieldOptions, ID as IDType } from '@nestjs/graphql';
+import { ID as IDType } from '@nestjs/graphql';
 import { ValidationOptions } from 'class-validator';
 import { IsAny, IsNever, Tagged } from 'type-fest';
 import type { ResourceName, ResourceNameLike } from '~/core';
+import { OptionalField, OptionalFieldOptions } from './optional-field';
 import { IsId } from './validators';
 
 export const IdField = ({
   validation,
   ...options
-}: FieldOptions & { validation?: ValidationOptions } = {}) =>
+}: OptionalFieldOptions & { validation?: ValidationOptions } = {}) =>
   applyDecorators(
-    Field(() => IDType, options),
+    OptionalField(() => IDType, {
+      optional: false,
+      ...options,
+    }),
     IsId(validation),
   );
 

src/common/index.ts

@@ -24,9 +24,11 @@ export * from './fiscal-year';
 export * from './generate-id';
 export * from './id.arg';
 export * from './lazy-ref';
+export * from './list-field';
 export * from './lazy-record';
 export { DateField, DateTimeField } from './luxon.graphql';
 export * from './map-or-else';
+export * from './optional-field';
 export * from './order.enum';
 export * from './pagination.input';
 export * from './pagination-list';

src/common/list-field.ts

@@ -0,0 +1,24 @@
+import { applyDecorators } from '@nestjs/common';
+import { ArrayNotEmpty } from 'class-validator';
+import { OptionalField, OptionalFieldOptions } from './optional-field';
+
+export type ListFieldOptions = OptionalFieldOptions & {
+  /**
+   * How should empty lists be handled?
+   */
+  empty?: 'allow' | 'omit' | 'deny';
+};
+
+export const ListField = (typeFn: () => any, options: ListFieldOptions) =>
+  applyDecorators(
+    OptionalField(() => [typeFn()], {
+      optional: false,
+      ...options,
+      transform: (value) => {
+        let out = value ? [...new Set(value)] : value;
+        out = options.empty === 'omit' && out.length === 0 ? undefined : out;
+        return options.transform ? options.transform(out) : out;
+      },
+    }),
+    ...(options.empty === 'deny' ? [ArrayNotEmpty()] : []),
+  );

src/common/luxon.graphql.ts

@@ -1,9 +1,10 @@
 import { applyDecorators } from '@nestjs/common';
-import { CustomScalar, Field, FieldOptions, Scalar } from '@nestjs/graphql';
+import { CustomScalar, Scalar } from '@nestjs/graphql';
 import { stripIndent } from 'common-tags';
 import { Kind, ValueNode } from 'graphql';
 import { DateTime, Settings } from 'luxon';
 import { InputException } from './exceptions';
+import { OptionalField, OptionalFieldOptions } from './optional-field';
 import { CalendarDate } from './temporal';
 import { Transform } from './transform.decorator';
 import { ValidateBy } from './validators/validateBy';
@@ -24,9 +25,12 @@ const IsIsoDate = () =>
     },
   });
 
-export const DateTimeField = (options?: FieldOptions) =>
+export const DateTimeField = (options?: OptionalFieldOptions) =>
   applyDecorators(
-    Field(() => DateTime, options),
+    OptionalField(() => DateTime, {
+      optional: false,
+      ...options,
+    }),
     Transform(
       ({ value }) => {
         try {
@@ -43,9 +47,12 @@ export const DateTimeField = (options?: FieldOptions) =>
     IsIsoDate(),
   );
 
-export const DateField = (options?: FieldOptions) =>
+export const DateField = (options?: OptionalFieldOptions) =>
   applyDecorators(
-    Field(() => CalendarDate, options),
+    OptionalField(() => CalendarDate, {
+      optional: false,
+      ...options,
+    }),
     Transform(
       ({ value }) => {
         try {

src/common/name-field.ts

@@ -7,9 +7,24 @@ import { MinLength } from 'class-validator';
 import { DbSort } from './db-sort.decorator';
 import { Transform } from './transform.decorator';
 
-export const NameField = (options: FieldOptions = {}) =>
+type NameFieldParams = FieldOptions & {
+  /**
+   * If true, values can be omitted/undefined or null.
+   * This will override `optional` if truthy.
+   */
+  nullable?: true;
+  /**
+   * If true, values can be omitted/undefined but not null.
+   */
+  optional?: true;
+};
+
+export const NameField = (options: NameFieldParams = {}) =>
   applyDecorators(
-    InferredTypeOrStringField(options),
+    InferredTypeOrStringField({
+      ...options,
+      nullable: options.optional ?? options.nullable,
+    }),
     Transform(({ value }) => {
       if (value === undefined) {
         return undefined;
@@ -18,14 +33,16 @@ export const NameField = (options: FieldOptions = {}) =>
         // Treat null & empty strings as null
         return value?.trim() || null;
       }
+      if (options.optional && value === null) {
+        // Treat null as an omitted value
+        return undefined;
+      }
       // Null & empty string treated as MinLength validation error
       return value?.trim() ?? '';
     }),
     DbSort((value) => `apoc.text.clean(${value})`),
     // Using this instead of @IsNotEmpty, as this allows nulls.
-    MinLength(1, {
-      message: 'Cannot be empty',
-    }),
+    MinLength(1, { message: 'Cannot be empty' }),
   );
 
 /**

src/common/optional-field.ts

@@ -0,0 +1,48 @@
+import { applyDecorators } from '@nestjs/common';
+import { Field, FieldOptions } from '@nestjs/graphql';
+import { NullableList } from '@nestjs/graphql/dist/interfaces/base-type-options.interface';
+import { Transform } from 'class-transformer';
+
+export type OptionalFieldOptions = FieldOptions & {
+  /**
+   * If true, values can be omitted/undefined or null.
+   * This will override `optional` if truthy.
+   */
+  nullable?: boolean | NullableList;
+  /**
+   * If true, values can be omitted/undefined but not null.
+   */
+  optional?: boolean;
+  transform?: (value: any) => unknown;
+};
+
+/**
+ * A field that is optional/omissible/can be undefined.
+ * Whether it can be explicitly null is based on `nullable`.
+ */
+export function OptionalField(
+  typeFn: () => any,
+  options?: OptionalFieldOptions,
+): PropertyDecorator;
+export function OptionalField(
+  options?: OptionalFieldOptions,
+): PropertyDecorator;
+export function OptionalField(...args: any) {
+  const typeFn: (() => any) | undefined =
+    typeof args[0] === 'function' ? (args[0] as () => any) : undefined;
+  const options: OptionalFieldOptions | undefined =
+    typeof args[0] === 'function' ? args[1] : args[0];
+  const opts = {
+    ...options,
+    nullable: options?.nullable ?? options?.optional ?? true,
+  };
+  return applyDecorators(
+    typeFn ? Field(typeFn, opts) : Field(opts),
+    Transform(({ value }) => {
+      if (!options?.nullable && (options?.optional ?? true) && value == null) {
+        return undefined;
+      }
+      return options?.transform ? options.transform(value) : value;
+    }),
+  );
+}

src/common/rich-text.scalar.ts

@@ -1,5 +1,5 @@
 import { applyDecorators } from '@nestjs/common';
-import { Field, FieldOptions, ObjectType } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
 import { setToStringTag } from '@seedcompany/common';
 import { markSkipClassTransformation } from '@seedcompany/nest';
 import { IsObject } from 'class-validator';
@@ -9,7 +9,8 @@ import { GraphQLJSONObject } from 'graphql-scalars';
 import { isEqual } from 'lodash';
 import { JsonObject } from 'type-fest';
 import { SecuredProperty } from '~/common/secured-property';
-import { Transform } from './transform.decorator';
+import { InputException } from './exceptions/input.exception';
+import { OptionalField, OptionalFieldOptions } from './optional-field';
 
 function hashId(name: string) {
   return createHash('shake256', { outputLength: 5 }).update(name).digest('hex');
@@ -76,11 +77,31 @@ export class RichTextDocument {
 setToStringTag(RichTextDocument, 'RichText');
 markSkipClassTransformation(RichTextDocument);
 
-export const RichTextField = (options?: FieldOptions) =>
+export const RichTextField = (options?: OptionalFieldOptions) =>
   applyDecorators(
-    Field(() => RichTextScalar, options),
+    OptionalField(() => RichTextScalar, {
+      optional: false,
+      ...options,
+      transform: (value) => {
+        const doc = RichTextDocument.fromMaybe(value);
+        if (doc) {
+          return doc;
+        }
+        if (options?.nullable) {
+          return null;
+        }
+        if (options?.optional) {
+          return undefined;
+        }
+        // Should never _really_ get here.
+        // UI should understand & send null instead of an empty document.
+        // Would prefer this to be done with validators.
+        // But I believe this needs to `null`s to be validated.
+        // skipMissingProperties -> skipUndefinedProperties
+        throw new InputException('RichText must be given');
+      },
+    }),
     IsObject(),
-    Transform(({ value }) => RichTextDocument.fromMaybe(value)),
   );
 
 /** @internal */

src/common/sensitivity.enum.ts

@@ -1,10 +1,9 @@
 import { applyDecorators } from '@nestjs/common';
-import { Field, FieldOptions } from '@nestjs/graphql';
 import { EnumType, makeEnum } from '@seedcompany/nest';
-import { Transform } from 'class-transformer';
-import { uniq } from 'lodash';
 import { rankSens } from '~/core/database/query';
 import { DbSort } from './db-sort.decorator';
+import { ListField, ListFieldOptions } from './list-field';
+import { OptionalField, OptionalFieldOptions } from './optional-field';
 
 export type Sensitivity = EnumType<typeof Sensitivity>;
 export const Sensitivity = makeEnum({
@@ -13,14 +12,22 @@ export const Sensitivity = makeEnum({
   exposeOrder: true,
 });
 
-export const SensitivityField = (options: FieldOptions = {}) =>
+export const SensitivityField = (options?: OptionalFieldOptions) =>
   applyDecorators(
-    Field(() => Sensitivity, options),
+    OptionalField(() => Sensitivity, {
+      optional: false,
+      ...options,
+    }),
     DbSort(rankSens),
   );
 
-export const SensitivitiesFilter = () =>
-  Transform(({ value }) => {
-    const sens = uniq(value);
-    return sens.length > 0 && sens.length < 3 ? sens : undefined;
+export const SensitivitiesFilterField = (options?: ListFieldOptions) =>
+  ListField(() => Sensitivity, {
+    description: 'Only these sensitivities',
+    ...options,
+    optional: true,
+    empty: 'omit',
+    transform: (value) =>
+      // If given all options, there is no need to filter
+      !value || value.length === Sensitivity.values.size ? undefined : value,
   });

src/components/ceremony/dto/list-ceremony.dto.ts

@@ -1,13 +1,12 @@
-import { Field, InputType } from '@nestjs/graphql';
-import { FilterField, SortablePaginationInput } from '~/common';
+import { InputType } from '@nestjs/graphql';
+import { FilterField, OptionalField, SortablePaginationInput } from '~/common';
 import { CeremonyType } from './ceremony-type.enum';
 import { Ceremony } from './ceremony.dto';
 
 @InputType()
 export abstract class CeremonyFilters {
-  @Field(() => CeremonyType, {
+  @OptionalField(() => CeremonyType, {
     description: 'Only ceremonies of this type',
-    nullable: true,
   })
   readonly type?: CeremonyType;
 }

src/components/ceremony/dto/update-ceremony.dto.ts

@@ -13,10 +13,10 @@ export abstract class UpdateCeremony {
   readonly planned?: boolean;
 
   @DateField({ nullable: true })
-  readonly estimatedDate?: CalendarDate;
+  readonly estimatedDate?: CalendarDate | null;
 
   @DateField({ nullable: true })
-  readonly actualDate?: CalendarDate;
+  readonly actualDate?: CalendarDate | null;
 }
 
 @InputType()