fix: use previous state on error

src/service-worker/request.ts

@@ -23,7 +23,7 @@ const get = async (options: RequestOptions) => {
     const response = await fetch(url, fetchOptions);
     logger.log('request.fetch', response);
     if (!response.ok) {
-        console.log('Request failed', errors.create(response, options.url));
+        logger.log('Request failed', errors.create(response, options.url));
         throw errors.create(response, options.url);
     }
     try {

src/service-worker/storage/service-state.test.ts

@@ -140,10 +140,51 @@ describe('updateService', () => {
             },
         ];
 
-        await stateStorage.updateService('name', items);
+        await stateStorage.updateService('service 1', items);
 
         expect(Storage.prototype.set).toBeCalledWith(
             expect.arrayContaining([expect.objectContaining({ offlineCount: 1 })])
         );
     });
+
+    it('uses previous state if error present', async () => {
+        testState = [
+            {
+                name: 'service',
+                items: [
+                    {
+                        id: 'build1',
+                        name: 'Build 1',
+                        group: null,
+                        isRunning: true,
+                        isBroken: true,
+                    },
+                ],
+            },
+        ];
+        (Storage.prototype.get as Mock).mockImplementation(() => testState);
+
+        const items: CIBuild[] = [
+            {
+                id: 'build1',
+                name: 'Build 1',
+                group: null,
+                error: { name: 'Error', message: 'error1' },
+            },
+        ];
+
+        await stateStorage.updateService('service', items);
+
+        expect(Storage.prototype.set).toBeCalledWith([
+            expect.objectContaining({
+                items: [
+                    expect.objectContaining({
+                        id: 'build1',
+                        isRunning: true,
+                        isBroken: true,
+                    }),
+                ],
+            }),
+        ]);
+    });
 });

src/service-worker/storage/service-state.ts

@@ -28,16 +28,27 @@ const reset = async (serviceNames: string[]) => {
 
 const updateService = async (serviceName: string, builds: CIBuild[]) => {
     logger.log('service-state.updateService', serviceName, builds);
+    const offlineCount = builds.filter(build => !build.isDisabled && build.error).length;
     const serviceState: ServiceStateItem = {
         name: serviceName,
         failedCount: builds.filter(build => !build.isDisabled && build.isBroken).length,
-        offlineCount: builds.filter(build => !build.isDisabled && build.error).length,
+        offlineCount,
         runningCount: builds.filter(build => !build.isDisabled && build.isRunning).length,
-        items: builds,
+        items: offlineCount > 0 ? await createErrorState(serviceName, builds) : builds,
     };
     setItem(serviceName, serviceState);
 };
 
+const createErrorState = async (serviceName: string, builds: CIBuild[]): Promise<CIBuild[]> => {
+    const oldState = await getItem(serviceName);
+    return builds.map(build => {
+        if (!build.error) return build;
+        const oldBuild = oldState.items?.find(old => old.id === build.id);
+        if (!oldBuild) return build;
+        return { ...oldBuild, error: build?.error  };
+    });
+};
+
 const getItem = async (serviceName: string) => {
     logger.log('service-state.getItem', serviceName);
     const allItems = await storage.get();
@@ -48,16 +59,15 @@ const getItem = async (serviceName: string) => {
 const setItem = async (serviceName: string, state: ServiceStateItem) => {
     logger.log('service-state.setItem', serviceName, state);
     const allItems = await storage.get();
-    const [found] = allItems.filter(state => state.name === serviceName);
-    let updatedState;
+    const found = allItems.find(state => state.name === serviceName);
+    let updatedState: ServiceStateItem[];
     if (found) {
         updatedState = allItems.map(item => {
             return item.name === serviceName ? state : item;
         });
     } else {
         updatedState = [...allItems, state];
     }
-    logger.log('service-state.setItem result', found, updatedState);
     await storage.set(updatedState);
 };
 

src/services/service-monitor.ts

@@ -24,7 +24,7 @@ const init = async () => {
 };
 
 const start = async () => {
-    console.log('service-monitor.start');
+    logger.log('service-monitor.start');
     updateAll(await serviceConfig.get());
 };