Merge pull request #3519 from SeedCompany/fix-nulls

Author: CarsonF

.eslintrc.cjs

@@ -207,6 +207,9 @@ const config = {
       { fixMixedExportsWithInlineTypeSpecifier: true },
     ],
     // TODO Enable this and fix errors (both types & logic changes will be needed)
+    // Remaining errors probably need individual thought.
+    // ESLint 9.24 allows bulk suppression,
+    // which we can use to enable this, and handle those cases one by one.
     '@typescript-eslint/no-unnecessary-condition': 'off',
 
     // Allow unused session while we migrate

src/common/date-filter.input.ts

@@ -1,7 +1,7 @@
 import { Field, InputType } from '@nestjs/graphql';
-import { DateTime } from 'luxon';
+import { type DateTime } from 'luxon';
 import { DateField, DateTimeField } from './luxon.graphql';
-import { CalendarDate } from './temporal';
+import { type CalendarDate } from './temporal';
 
 @InputType({
   description: 'A filter range designed for date fields',
@@ -11,25 +11,25 @@ export abstract class DateFilter {
     description: 'After this day',
     nullable: true,
   })
-  after?: CalendarDate;
+  after?: CalendarDate | null;
 
   @DateField({
     description: 'After or equal to this day',
     nullable: true,
   })
-  afterInclusive?: CalendarDate;
+  afterInclusive?: CalendarDate | null;
 
   @DateField({
     description: 'Before this day',
     nullable: true,
   })
-  before?: CalendarDate;
+  before?: CalendarDate | null;
 
   @DateField({
     description: 'Before or equal to this day',
     nullable: true,
   })
-  beforeInclusive?: CalendarDate;
+  beforeInclusive?: CalendarDate | null;
 
   @Field({ description: 'Whether the field is null or not', nullable: true })
   isNull?: boolean;
@@ -43,25 +43,25 @@ export abstract class DateTimeFilter {
     description: 'After this time',
     nullable: true,
   })
-  after?: DateTime;
+  after?: DateTime | null;
 
   @DateTimeField({
     description: 'After or equal to this time',
     nullable: true,
   })
-  afterInclusive?: DateTime;
+  afterInclusive?: DateTime | null;
 
   @DateTimeField({
     description: 'Before this time',
     nullable: true,
   })
-  before?: DateTime;
+  before?: DateTime | null;
 
   @DateTimeField({
     description: 'Before or equal to this time',
     nullable: true,
   })
-  beforeInclusive?: DateTime;
+  beforeInclusive?: DateTime | null;
 
   @Field({ description: 'Whether the field is null or not', nullable: true })
   isNull?: boolean;

src/common/exceptions/service-unavailable.exception.ts

@@ -5,7 +5,7 @@ export class TransientException extends ServerException {}
 
 export class ServiceUnavailableException extends TransientException {
   readonly status = HttpStatus.SERVICE_UNAVAILABLE;
-  constructor(message: string, previous?: Error) {
+  constructor(message?: string, previous?: Error) {
     super(message ?? 'Service Unavailable', previous);
   }
 }

src/common/name-field.ts

@@ -51,9 +51,13 @@ export const NameField = (options: NameFieldParams = {}) =>
  */
 const InferredTypeOrStringField =
   (options: FieldOptions): PropertyDecorator | MethodDecorator =>
-  (prototype, property, descriptor) => {
+  (prototype, property, descriptorRaw) => {
     const propertyKey = property as string;
     const applyMetadataFn = () => {
+      // fix linter false positive thinking it always exists, property decorators don't have it
+      const descriptor = descriptorRaw as
+        | TypedPropertyDescriptor<unknown>
+        | undefined;
       const isResolver = !!descriptor;
       const isResolverMethod = !!descriptor?.value;
       const resolveType = (typeFn?: ReturnTypeFunc) =>

src/common/poll.ts

@@ -48,7 +48,7 @@ export class PollResults<T> {
   /** Returns the unanimous vote, if there was one */
   get unanimous() {
     const all = this.sorted;
-    return all.length === 1 ? all[0][0] : undefined;
+    return all.length === 1 ? all[0]![0] : undefined;
   }
 
   /** Returns all votes sorted by most voted first (ties are unaccounted for) */

src/common/required-when.ts

@@ -1,4 +1,8 @@
-import { groupBy } from '@seedcompany/common';
+import {
+  asNonEmptyArray,
+  groupBy,
+  type NonEmptyArray,
+} from '@seedcompany/common';
 import { createMetadataDecorator } from '@seedcompany/nest';
 import { InputException } from './exceptions';
 import { type ID } from './id-field';
@@ -50,7 +54,7 @@ RequiredWhen.calc = <TResourceStatic extends ResourceShape<any>>(
     const condition = RequiredWhenMetadata.get(resource, prop);
     return condition ? { ...condition, field: prop } : [];
   });
-  const missing = conditions.flatMap((condition) => {
+  const missingList = conditions.flatMap((condition) => {
     return condition.isEnabled(obj) &&
       (condition.isMissing?.(obj) ?? obj[condition.field] == null)
       ? {
@@ -59,8 +63,10 @@ RequiredWhen.calc = <TResourceStatic extends ResourceShape<any>>(
         }
       : [];
   });
-  if (missing.length > 0) {
-    return new MissingRequiredFieldsException(res, { id: obj.id }, missing);
+  const missing = asNonEmptyArray(missingList);
+  if (missing) {
+    const id = obj.id as ID;
+    return new MissingRequiredFieldsException(res, { id }, missing);
   }
   return undefined;
 };
@@ -79,7 +85,7 @@ export class MissingRequiredFieldsException extends InputException {
   constructor(
     readonly resource: EnhancedResource<any>,
     readonly object: { id: ID },
-    readonly missing: ReadonlyArray<{
+    readonly missing: NonEmptyArray<{
       readonly field: string;
       readonly description: string;
     }>,

src/common/resource.dto.ts

@@ -1,6 +1,7 @@
 import { CLASS_TYPE_METADATA, Field, InterfaceType } from '@nestjs/graphql';
 import { type ClassType as ClassTypeVal } from '@nestjs/graphql/dist/enums/class-type.enum.js';
 import {
+  asNonEmptyArray,
   cached,
   type FnLike,
   mapValues,
@@ -109,7 +110,12 @@ export class EnhancedResource<T extends ResourceShape<any>> {
   >();
 
   static resolve(ref: ResourceLike) {
-    if (ref && typeof ref !== 'string') {
+    // Safety check; since this very dynamic code, it is very possible the types are lying.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (ref == null) {
+      throw new ServerException('Resource reference is actually null');
+    }
+    if (typeof ref !== 'string') {
       return EnhancedResource.of(ref);
     }
     if (!EnhancedResource.resourcesHost) {
@@ -316,7 +322,7 @@ export class EnhancedResource<T extends ResourceShape<any>> {
       const declared = DbLabel.getOwn(cls);
       return declared ? [...declared] : [cls.name];
     });
-    return [...new Set([...labels, 'BaseNode'])];
+    return asNonEmptyArray([...new Set([...labels, 'BaseNode'])])!;
   }
   get dbLabel() {
     return this.dbLabels[0];

src/common/retry.ts

@@ -30,13 +30,13 @@ export type RetryOptions = Merge<
 
 const parseOptions = (options: RetryOptions = {}): Options => ({
   ...options,
-  maxRetryTime: options?.maxRetryTime
+  maxRetryTime: options.maxRetryTime
     ? Duration.from(options.maxRetryTime).toMillis()
     : undefined,
-  minTimeout: options?.minTimeout
+  minTimeout: options.minTimeout
     ? Duration.from(options.minTimeout).toMillis()
     : undefined,
-  maxTimeout: options?.maxTimeout
+  maxTimeout: options.maxTimeout
     ? Duration.from(options.maxTimeout).toMillis()
     : undefined,
 });

src/common/search-camel-case.ts

@@ -20,7 +20,7 @@ import { startCase } from 'lodash';
 export function searchCamelCase<T extends string>(
   items: Iterable<T>,
   needle: string,
-) {
+): readonly T[] {
   const itemArr = [...items];
   const collator = new Intl.Collator('en');
   const fuzzy = new Fuzzy({
@@ -41,22 +41,22 @@ export function searchCamelCase<T extends string>(
         .sort(
           (ia, ib) =>
             // most contiguous chars matched
-            chars[ib] - chars[ia] ||
+            chars[ib]! - chars[ia]! ||
             // least char intra-fuzz (most contiguous)
-            intraIns[ia] - intraIns[ib] ||
+            intraIns[ia]! - intraIns[ib]! ||
             // earliest start of match
-            start[ia] - start[ib] ||
+            start[ia]! - start[ib]! ||
             // shortest match first
-            haystack[idx[ia]].length - haystack[idx[ib]].length ||
+            haystack[idx[ia]!]!.length - haystack[idx[ib]!]!.length ||
             // most prefix bounds, boosted by full term matches
-            terms[ib] +
-              interLft2[ib] +
-              0.5 * interLft1[ib] -
-              (terms[ia] + interLft2[ia] + 0.5 * interLft1[ia]) ||
+            terms[ib]! +
+              interLft2[ib]! +
+              0.5 * interLft1[ib]! -
+              (terms[ia]! + interLft2[ia]! + 0.5 * interLft1[ia]!) ||
             // the highest density of match (the least term inter-fuzz)
-            interIns[ia] - interIns[ib] ||
+            interIns[ia]! - interIns[ib]! ||
             // alphabetic
-            collator.compare(haystack[idx[ia]], haystack[idx[ib]]),
+            collator.compare(haystack[idx[ia]!]!, haystack[idx[ib]!]!),
         );
     },
   });
@@ -74,6 +74,6 @@ export function searchCamelCase<T extends string>(
     return [];
   }
 
-  const results = order.map((idx) => itemArr[indexes[idx]]);
+  const results = order.map((idx) => itemArr[indexes[idx]!]!);
   return results;
 }

src/common/variant.dto.ts

@@ -90,7 +90,7 @@ export const VariantInputField = <
       ? resource.Variants.find((v) => v.key === value)
       : value;
   const defaultVariant = many
-    ? (defaultValue as any[])?.map(resolveVariant)
+    ? (defaultValue as any[] | undefined)?.map(resolveVariant)
     : resolveVariant(defaultValue as VariantOf<Res>);
 
   return applyDecorators(