fix: steps added in v2 and handle 403 errors

package.json

@@ -42,6 +42,7 @@
     "@jupiterone/integration-sdk-dev-tools": "^8.30.2",
     "@jupiterone/integration-sdk-testing": "^8.30.2",
     "@types/node": "^18.8.3",
+    "@types/node-fetch": "^2.6.2",
     "jest-fetch-mock": "^3.0.3",
     "type-fest": "^0.20.2"
   },

src/collector/ServicesClient.ts

@@ -5,7 +5,16 @@ import { retry } from '@lifeomic/attempt';
 
 import { IntegrationConfig } from '../types';
 import { fatalRequestError, retryableRequestError } from './error';
-import { HardwareAsset, PaginatedResponse, SnipeItUser } from './types';
+import {
+  HardwareAsset,
+  PaginatedResponse,
+  SnipeItUser,
+  ResourceIteratee,
+  HardwareLicense,
+  SnipeItConsumable,
+  ConsumableUser,
+  Location,
+} from './types';
 
 /**
  * Services Api
@@ -25,61 +34,59 @@ export class ServicesClient {
   }
 
   async fetchUser(username: string): Promise<SnipeItUser | undefined> {
-    const usersResponse = await this.fetch<PaginatedResponse>('users', {
-      search: username,
-    });
+    const usersResponse = await this.fetch<PaginatedResponse<SnipeItUser>>(
+      'users',
+      {
+        search: username,
+      },
+    );
     if (usersResponse.total > 0) return usersResponse.rows[0];
   }
 
-  async iterateHardware(
-    iteratee: (asset: HardwareAsset) => Promise<void>,
-  ): Promise<void> {
-    const limit = 500;
-    let offset = 0;
-    let total = 0;
-
-    do {
-      const response: PaginatedResponse = await this.fetch('hardware', {
-        offset: offset.toString(),
-      });
-      if (!response.rows) {
-        break;
-      }
-      total = response.total;
-      offset += limit;
-      for (const resource of response.rows) {
-        await iteratee(resource);
-      }
-    } while (offset < total);
+  async iterateHardware(iteratee: ResourceIteratee<HardwareAsset>) {
+    const hardwareAssets = await this.iterateAll<HardwareAsset>('hardware');
+    for (const hardware of hardwareAssets) {
+      await iteratee(hardware);
+    }
   }
 
-  listLocations(): Promise<object[]> {
-    return this.iterateAll('locations');
+  listLocations() {
+    return this.iterateAll<Location>('locations');
   }
 
-  listConsumables(): Promise<object[]> {
-    return this.iterateAll('consumables');
+  listConsumables() {
+    return this.iterateAll<SnipeItConsumable>('consumables');
   }
 
-  listHardwareLicenses(id: number): Promise<object[]> {
-    return this.iterateAll(`hardware/${id}/licenses`);
+  async iterateHardwareLicenses(
+    id: number,
+    iteratee: ResourceIteratee<HardwareLicense>,
+  ) {
+    const licenses = await this.iterateAll<HardwareLicense>(
+      `hardware/${id}/licenses`,
+    );
+    for (const license of licenses) {
+      await iteratee(license);
+    }
   }
 
-  listUsers(): Promise<object[]> {
-    return this.iterateAll('users');
+  listUsers() {
+    return this.iterateAll<SnipeItUser>('users');
   }
 
-  listConsumableUsers(consumableId: string): Promise<object[]> {
-    return this.iterateAll(`consumables/view/${consumableId}/users`);
+  listConsumableUsers(consumableId: string) {
+    return this.iterateAll<ConsumableUser>(
+      `consumables/view/${consumableId}/users`,
+    );
   }
 
-  async iterateAll<T = object[]>(url: string): Promise<T> {
-    const data: any[] = [];
+  async iterateAll<T = unknown>(url: string): Promise<T[]> {
+    const data: T[] = [];
     const limit = 500;
     let offset = 0;
     let total = 0;
     do {
-      const response: PaginatedResponse = await this.fetch(url, {
+      const response = await this.fetch<PaginatedResponse<T>>(url, {
         offset: offset.toString(),
         limit: limit.toString(),
       });
@@ -90,7 +97,7 @@ export class ServicesClient {
       offset += limit;
       data.push(...response.rows);
     } while (offset < total);
-    return (data as unknown) as T;
+    return data;
   }
 
   fetch<T = object>(

src/collector/error.ts

@@ -4,14 +4,23 @@ export class RetryableError extends Error {
   retryable = true;
 }
 
+export class FatalRequestError extends Error {
+  public statusCode: number;
+  constructor(message: string, statusCode: number) {
+    super(message);
+    this.statusCode = statusCode;
+  }
+}
+
 export function retryableRequestError(response: Response): RetryableError {
   return new RetryableError(
     `Encountered retryable response from provider (status=${response.status})`,
   );
 }
 
 export function fatalRequestError(response: Response): Error {
-  return new Error(
+  return new FatalRequestError(
     `Encountered unexpected response from provider (status="${response.status}")`,
+    response.status,
   );
 }