Enable noUncheckedIndexedAccess

Mostly these asserts are:
- asserting group in regex match
- asserting first element, after checking length

Other changes are:
- Declaring lists as NonEmptyArray<T>
- Using `asNonEmptyArray` to narrow to filled list, replacing `list.length === 0` checks

Author: CarsonF

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,
@@ -316,7 +317,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/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/xlsx.util.ts

@@ -62,7 +62,8 @@ export class WorkBook {
       if (!matched) {
         return SKIP;
       }
-      const [_, sheetName, rangeStr] = matched;
+      const sheetName = matched[1]!;
+      const rangeStr = matched[2]!;
       try {
         const range = this.sheet(sheetName).range(rangeStr);
         return [name, range];
@@ -96,10 +97,11 @@ export class Sheet {
       this.book = arg;
       // @ts-expect-error yeah it's private this seems like the easiest way though
       this.workbook = this.book.book;
-      this.sheet = this.workbook.Sheets[this.name];
-      if (!this.sheet) {
+      const sheet = this.workbook.Sheets[this.name];
+      if (!sheet) {
         throw new NotFoundException(`Cannot find ${this.name} sheet`);
       }
+      this.sheet = sheet;
     }
     nonEnumerable(this, 'workbook' as any, 'sheet' as any);
   }
@@ -233,8 +235,8 @@ export class Cell<TSheet extends Sheet = Sheet> {
   }
 
   @Once() get hidden() {
-    const colHidden = this.libSheet['!cols']?.[this.address.c].hidden ?? false;
-    const rowHidden = this.libSheet['!rows']?.[this.address.r].hidden ?? false;
+    const colHidden = this.libSheet['!cols']?.[this.address.c]?.hidden ?? false;
+    const rowHidden = this.libSheet['!rows']?.[this.address.r]?.hidden ?? false;
     return colHidden || rowHidden;
   }
 

src/components/authorization/policies/conditions/creator.condition.ts

@@ -1,4 +1,5 @@
 import { Logger } from '@nestjs/common';
+import { type NonEmptyArray } from '@seedcompany/common';
 import { inspect, type InspectOptionsStylized } from 'util';
 import {
   type ID,
@@ -58,11 +59,11 @@ class CreatorCondition<TResourceStatic extends ResourceShape<HasCreator>>
     return '.isCreator';
   }
 
-  union(this: void, conditions: this[]) {
+  union(this: void, conditions: NonEmptyArray<this>) {
     return conditions[0];
   }
 
-  intersect(this: void, conditions: this[]) {
+  intersect(this: void, conditions: NonEmptyArray<this>) {
     return conditions[0];
   }
 

src/components/authorization/policies/conditions/enum-field.condition.ts

@@ -1,4 +1,4 @@
-import { groupBy } from '@seedcompany/common';
+import { groupBy, type NonEmptyArray } from '@seedcompany/common';
 import { type Query } from 'cypher-query-builder';
 import { get, startCase } from 'lodash';
 import type { Get, Paths } from 'type-fest';
@@ -55,7 +55,7 @@ export class EnumFieldCondition<
     return '<str>' + eqlInLiteralSet(`.${this.path}`, this.allowed);
   }
 
-  union(conditions: this[]): Array<Condition<TResourceStatic>> {
+  union(this: void, conditions: NonEmptyArray<this>) {
     return groupBy(conditions, (c) => c.path).map((conditionsForField) => {
       const unioned = conditionsForField.flatMap((c) => [...c.allowed]);
       return new EnumFieldCondition(
@@ -66,7 +66,7 @@ export class EnumFieldCondition<
     });
   }
 
-  intersect(conditions: this[]): Array<Condition<TResourceStatic>> {
+  intersect(this: void, conditions: NonEmptyArray<this>) {
     return groupBy(conditions, (c) => c.path).map((conditionsForField) => {
       const intersected = [...conditionsForField[0].allowed].filter((v) =>
         conditionsForField.every((condition) => condition.allowed.has(v)),

src/components/authorization/policies/conditions/member.condition.ts

@@ -1,3 +1,4 @@
+import { type NonEmptyArray } from '@seedcompany/common';
 import { type Query } from 'cypher-query-builder';
 import { intersection } from 'lodash';
 import { inspect, type InspectOptionsStylized } from 'util';
@@ -50,11 +51,11 @@ class MemberCondition<TResourceStatic extends ResourceWithScope>
     return resource.isEmbedded ? 'isMember' : '.isMember';
   }
 
-  union(this: void, conditions: this[]) {
+  union(this: void, conditions: NonEmptyArray<this>) {
     return conditions[0];
   }
 
-  intersect(this: void, conditions: this[]) {
+  intersect(this: void, conditions: NonEmptyArray<this>) {
     return conditions[0];
   }
 

src/components/authorization/policies/conditions/role-and-exp-union.optimizer.ts

@@ -1,4 +1,4 @@
-import { groupBy } from '@seedcompany/common';
+import { asNonEmptyArray, groupBy } from '@seedcompany/common';
 import { mapOrElse } from '~/common';
 import {
   all,
@@ -43,8 +43,8 @@ export class RoleAndExpUnionOptimizer implements Optimizer {
     }
 
     const merged = groupedByX.map((group) => {
-      const { role, x } = group[0]!;
-      const roles = role.union(group.map((c) => c.role));
+      const { role, x } = group[0];
+      const roles = role.union(asNonEmptyArray(group.map((c) => c.role))!);
       return all(roles, x);
     });
 
@@ -65,7 +65,7 @@ export class RoleAndExpUnionOptimizer implements Optimizer {
       return null;
     }
     const role = condition.conditions[roleIdx] as RoleCondition;
-    const x = condition.conditions[roleIdx === 0 ? 1 : 0];
+    const x = condition.conditions[roleIdx === 0 ? 1 : 0]!;
     const xId = Condition.id(x);
     return { role, x, xId };
   }

src/components/authorization/policies/conditions/role.condition.ts

@@ -1,3 +1,4 @@
+import { type NonEmptyArray } from '@seedcompany/common';
 import { inspect } from 'util';
 import { type Role } from '~/common';
 import {
@@ -27,12 +28,12 @@ export class RoleCondition implements Condition {
     return eqlDoesIntersect(currentRoles, this.allowed, roleType);
   }
 
-  union(this: void, conditions: this[]) {
+  union(this: void, conditions: NonEmptyArray<this>) {
     const roles = conditions.flatMap((cond) => [...cond.allowed]);
     return new RoleCondition(new Set(roles));
   }
 
-  intersect(this: void, conditions: this[]) {
+  intersect(this: void, conditions: NonEmptyArray<this>) {
     const intersected = [...conditions[0].allowed].filter((v) =>
       conditions.every((cond) => cond.allowed.has(v)),
     );