Merge pull request #144 from import-ai/fix/task_callback

fix(task): Fix task callback with empty but not null exception

Author: LucienShui

src/utils/is-empty.spec.ts

@@ -0,0 +1,26 @@
+import { isEmpty } from './is-empty';
+
+describe('isEmpty', () => {
+  test.each([
+    // Empty values - should return true
+    ['', true, 'empty string'],
+    [[], true, 'empty array'],
+    [{}, true, 'empty object'],
+    [null, true, 'empty object'],
+    [undefined, true, 'empty object'],
+
+    // Non-empty values - should return false
+    ['hello', false, 'non-empty string'],
+    [' ', false, 'string with space'],
+    ['0', false, 'string with zero'],
+    [[1], false, 'array with one element'],
+    [[1, 2, 3], false, 'array with multiple elements'],
+    [[null], false, 'array with null element'],
+    [[undefined], false, 'array with undefined element'],
+    [{ a: 1 }, false, 'object with property'],
+    [{ a: null }, false, 'object with null value'],
+    [{ a: undefined }, false, 'object with undefined value'],
+  ])('should return %s for %s (%s)', (input, expected, description) => {
+    expect(isEmpty(input)).toBe(expected);
+  });
+});

src/utils/is-empty.ts

@@ -0,0 +1,32 @@
+/**
+ * Checks if a string, array, or record is empty.
+ *
+ * @param value - The value to check (string, array, or record)
+ * @returns true if the value is empty, false otherwise
+ *
+ * @example
+ * isEmpty('') // true
+ * isEmpty([]) // true
+ * isEmpty({}) // true
+ * isEmpty('hello') // false
+ * isEmpty([1, 2, 3]) // false
+ * isEmpty({ a: 1 }) // false
+ */
+export function isEmpty(
+  value: string | any[] | Record<string, any> | undefined | null,
+): boolean {
+  if (value === undefined || value === null) {
+    return true; // null, undefined are considered empty
+  }
+  if (typeof value === 'string' || Array.isArray(value)) {
+    return value.length === 0;
+  }
+
+  if (typeof value === 'object' && value.constructor === Object) {
+    return Object.keys(value).length === 0;
+  }
+
+  throw new TypeError(
+    'Expected a string, array, or record, but received: ' + typeof value,
+  );
+}

src/wizard/processors/collect.processor.ts

@@ -2,6 +2,7 @@ import { ResourcesService } from 'omniboxd/resources/resources.service';
 import { Task } from 'omniboxd/tasks/tasks.entity';
 import { BadRequestException } from '@nestjs/common';
 import { Processor } from 'omniboxd/wizard/processors/processor.abstract';
+import { isEmpty } from 'omniboxd/utils/is-empty';
 
 export class CollectProcessor extends Processor {
   constructor(protected readonly resourcesService: ResourcesService) {
@@ -13,7 +14,7 @@ export class CollectProcessor extends Processor {
     if (!resourceId) {
       throw new BadRequestException('Invalid task payload');
     }
-    if (task.exception) {
+    if (task.exception && !isEmpty(task.exception)) {
       await this.resourcesService.update(task.userId, resourceId, {
         namespaceId: task.namespaceId,
         content: task.exception.error,

src/wizard/processors/reader.processor.spec.ts

@@ -387,6 +387,21 @@ describe('ReaderProcessor', () => {
         expect(attachmentsService.uploadAttachment).toHaveBeenCalled();
         expect(task.output!.images).toBeUndefined();
       });
+
+      it('empty dict exception', async () => {
+        const task = createMockTask({
+          exception: {},
+          output: {
+            markdown: '# Test Document',
+          },
+        });
+
+        resourcesService.get.mockResolvedValue(mockResource as Resource);
+        resourcesService.update.mockResolvedValue(undefined);
+
+        const result = await processor.process(task);
+        expect(result).toEqual({ resourceId: 'test-resource-id' });
+      });
     });
   });
 });