improve type safety with generic Entity interface and extracted test utilities

Author: wilburhimself

src/lib/mutation.test.ts

@@ -1,26 +1,5 @@
 import buildMutation from './mutation';
-import type { Entity } from './resolver';
-
-function makeEntity(initial: Array<Record<string, any>> = []): Entity & {
-  _store: Array<Record<string, any>>;
-} {
-  const store = initial.map((r) => ({ ...r }));
-  return {
-    _store: store,
-    rawAttributes: { id: {}, name: {} },
-    findOne: async ({ where: { id } }: any) => store.find((r) => r.id === id) ?? null,
-    findAndCountAll: async () => ({ rows: store }),
-    create: async (item: any) => {
-      store.push(item);
-      return item;
-    },
-    update: async (item: any, { where: { id } }: any) => {
-      const idx = store.findIndex((r) => r.id === id);
-      if (idx >= 0) store[idx] = { ...store[idx], ...item };
-      return [1];
-    },
-  } as unknown as Entity & { _store: Array<Record<string, any>> };
-}
+import { makeEntity } from './testUtils/fakeEntity';
 
 describe('buildMutation', () => {
   test('create mutation resolves to created entity', async () => {

src/lib/query.test.ts

@@ -1,28 +1,6 @@
 import buildQuery from './query';
-import type { Entity } from './resolver';
 import { GraphQLObjectType, GraphQLInt } from 'graphql';
-
-// Minimal fake entity implementation
-function makeEntity(initial: Array<Record<string, any>> = []): Entity & {
-  _store: Array<Record<string, any>>;
-} {
-  const store = initial.map((r) => ({ ...r }));
-  return {
-    _store: store,
-    rawAttributes: { id: {}, name: {} },
-    findOne: async ({ where: { id } }: any) => store.find((r) => r.id === id) ?? null,
-    findAndCountAll: async () => ({ rows: store }),
-    create: async (item: any) => {
-      store.push(item);
-      return item;
-    },
-    update: async (item: any, { where: { id } }: any) => {
-      const idx = store.findIndex((r) => r.id === id);
-      if (idx >= 0) store[idx] = { ...store[idx], ...item };
-      return [1];
-    },
-  } as unknown as Entity & { _store: Array<Record<string, any>> };
-}
+import { makeEntity } from './testUtils/fakeEntity';
 
 describe('buildQuery', () => {
   test('resolves by id returns array of one resolved item', async () => {

src/lib/resolver.ts

@@ -23,18 +23,18 @@ type AllOptions = {
   all?: boolean;
 };
 
-class Resolver {
-  private entity: Entity;
+class Resolver<T extends Record<string, unknown> = Record<string, unknown>> {
+  private entity: Entity<T>;
 
-  constructor(entity: Entity) {
+  constructor(entity: Entity<T>) {
     this.entity = entity;
   }
 
-  find(id: number | string) {
+  find(id: number | string): Promise<T | null> {
     return this.entity.findOne({ where: { id: id } }).then((items) => items);
   }
 
-  all(options?: AllOptions) {
+  all(options?: AllOptions): Promise<T[]> {
     const hasNameField = Object.getOwnPropertyNames(this.entity.rawAttributes).indexOf('name') == 1;
     const defaults = {
       perPage: Number(process.env.APP_PERPAGE),
@@ -58,20 +58,22 @@ class Resolver {
     return this.entity.findAndCountAll(queryOptions).then((items) => items.rows);
   }
 
-  create(item: Record<string, unknown>) {
+  create(item: Partial<T>): Promise<T> {
     return this.entity.create(item).then((result) => result);
   }
 
-  update(id: number | string, item: Record<string, unknown>) {
+  update<TId extends number | string, TInput extends Partial<T>>(id: TId, item: TInput): Promise<T | null> {
     return this.entity.update(item, { where: { id: id } }).then(() => this.find(id));
   }
 
   page(pageNumber: number) {
     return Number(process.env.APP_PERPAGE) * pageNumber;
   }
 
-  destroy(id: number | string) {
-    return this.entity.update({ enable: false }, { where: { id: id } }).then(() => this.find(id));
+  destroy(id: number | string): Promise<T | null> {
+    return this.entity
+      .update({ enable: false } as unknown as Partial<T>, { where: { id: id } })
+      .then(() => this.find(id));
   }
 }
 

src/lib/testUtils/fakeEntity.ts

@@ -0,0 +1,45 @@
+import type { Entity } from '../resolver';
+
+export type FakeRow = { id: number | string } & Record<string, unknown>;
+
+export function makeEntity(initial: FakeRow[] = []): (Entity<FakeRow> & { _store: FakeRow[] }) {
+  const store = initial.map((r) => ({ ...r })) as FakeRow[];
+  return {
+    _store: store,
+    rawAttributes: { id: {}, name: {} },
+    findOne: async ({ where: { id } }: { where: { id: number | string } }) =>
+      (store.find((r) => r.id === id) ?? null),
+    findAndCountAll: async () => ({ rows: store }),
+    create: async (item: Partial<FakeRow>) => {
+      const next = { ...item } as FakeRow;
+      store.push(next);
+      return next;
+    },
+    update: async (item: Partial<FakeRow>, { where: { id } }: { where: { id: number | string } }) => {
+      const idx = store.findIndex((r) => r.id === id);
+      if (idx >= 0) store[idx] = { ...store[idx], ...item } as FakeRow;
+      return [1];
+    },
+  } as unknown as Entity<FakeRow> & { _store: FakeRow[] };
+}
+
+export function makeEntityNoName(initial: FakeRow[] = []): (Entity<FakeRow> & { _store: FakeRow[] }) {
+  const store = initial.map((r) => ({ ...r })) as FakeRow[];
+  return {
+    _store: store,
+    rawAttributes: { id: {} },
+    findOne: async ({ where: { id } }: { where: { id: number | string } }) =>
+      (store.find((r) => r.id === id) ?? null),
+    findAndCountAll: async () => ({ rows: store }),
+    create: async (item: Partial<FakeRow>) => {
+      const next = { ...item } as FakeRow;
+      store.push(next);
+      return next;
+    },
+    update: async (item: Partial<FakeRow>, { where: { id } }: { where: { id: number | string } }) => {
+      const idx = store.findIndex((r) => r.id === id);
+      if (idx >= 0) store[idx] = { ...store[idx], ...item } as FakeRow;
+      return [1];
+    },
+  } as unknown as Entity<FakeRow> & { _store: FakeRow[] };
+}

src/types/express-graphql.d.ts

@@ -8,11 +8,11 @@ declare module 'express-graphql' {
     graphiql?: boolean;
     context?: unknown;
     pretty?: boolean;
-    formatError?: (error: any) => any;
-    extensions?: (info: any) => any;
-    validationRules?: any[];
-    customFormatErrorFn?: (error: any) => any;
+    formatError?: (error: unknown) => unknown;
+    extensions?: (info: unknown) => unknown;
+    validationRules?: unknown[];
+    customFormatErrorFn?: (error: unknown) => unknown;
   }
 
-  export default function graphqlHTTP(options: Options | ((req: any) => Options)): RequestHandler;
+  export default function graphqlHTTP(options: Options | ((req: unknown) => Options)): RequestHandler;
 }

src/types/sequelize.d.ts

@@ -1,4 +1,4 @@
 declare module 'sequelize' {
-  const Sequelize: any;
+  const Sequelize: unknown;
   export default Sequelize;
 }