feat: Improve error handling in services and update related tests for consistency

Author: Smilefounder

packages/database/src/mix-database-data-rest-portal-service.ts

@@ -68,23 +68,15 @@ export class MixDatabaseDataRestPortalService {
       return { isSucceed: false, errors: ['Missing file'] };
     }
     const endpoint = `${this.prefixUrl}/import-data/${mixDatabaseName}`;
+    if (!mixDatabaseName) {
+      return { isSucceed: false, errors: ['Missing mixDatabaseName'] };
+    }
+    if (!file) {
+      return { isSucceed: false, errors: ['Missing file'] };
+    }
     const formData = new FormData();
     formData.append('file', file);
-    const url = new URL(endpoint, this.api['config'].apiBaseUrl).toString();
-    try {
-      const res = await fetch(url, {
-        method: 'POST',
-        body: formData,
-        headers: this.api['config'].apiKey ? { 'Authorization': `Bearer ${this.api['config'].apiKey}` } : undefined,
-      });
-      const data = await res.json().catch(() => undefined);
-      if (!res.ok) {
-        return { isSucceed: false, data, errors: [res.statusText], status: res.status };
-      }
-      return { isSucceed: true, data, status: res.status };
-    } catch (err) {
-      return { isSucceed: false, errors: [(err as Error).message] };
-    }
+    return this.api.post(endpoint, formData, { isFormData: true });
   }
 
   /**

packages/database/src/module-data-rest-mvc-service.ts

@@ -24,7 +24,7 @@ export class ModuleDataRestMvcService {
    */
   async initForm(moduleId: string): Promise<ApiResult> {
     if (!moduleId) {
-      return { isSucceed: false, errors: ['Missing moduleId'] };
+      throw new Error('Missing moduleId');
     }
     const endpoint = `${this.prefixUrl}/init-form/${moduleId}`;
     return this.api.get(endpoint);

packages/database/tests/mix-database-column-rest-service.test.ts

@@ -1,5 +1,5 @@
-import { ApiService } from './api-services';
-import { MixDatabaseColumnRestService } from './mix-database-column-rest-service';
+import { ApiService } from '@mixcore/api';
+import { MixDatabaseColumnRestService } from '../src/mix-database-column-rest-service';
 
 describe('MixDatabaseColumnRestService', () => {
   let api: ApiService;
@@ -14,8 +14,10 @@ describe('MixDatabaseColumnRestService', () => {
     expect(columnService).toBeInstanceOf(MixDatabaseColumnRestService);
   });
 
-  it('should throw if no mixDatabaseName provided', async () => {
-    await expect(columnService.initData('')).rejects.toThrow('Missing mixDatabaseName');
+  it('should return error if no mixDatabaseName provided', async () => {
+    const result = await columnService.initData('');
+    expect(result.isSucceed).toBe(false);
+    expect(result.errors).toContain('Missing mixDatabaseName');
   });
 
   it('should call initData', async () => {

packages/database/tests/mix-database-data-rest-client-service.test.ts

@@ -1,5 +1,5 @@
-import { ApiService } from './api-services';
-import { MixDatabaseDataRestClientService } from './mix-database-data-rest-client-service';
+import { ApiService } from '@mixcore/api';
+import { MixDatabaseDataRestClientService } from '../src/mix-database-data-rest-client-service';
 
 describe('MixDatabaseDataRestClientService', () => {
   let api: ApiService;
@@ -14,8 +14,10 @@ describe('MixDatabaseDataRestClientService', () => {
     expect(clientService).toBeInstanceOf(MixDatabaseDataRestClientService);
   });
 
-  it('should throw if no mixDatabaseName for initData', async () => {
-    await expect(clientService.initData('')).rejects.toThrow('Missing mixDatabaseName');
+  it('should return error if no mixDatabaseName for initData', async () => {
+    const result = await clientService.initData('');
+    expect(result.isSucceed).toBe(false);
+    expect(result.errors).toContain('Missing mixDatabaseName');
   });
 
   it('should call initData', async () => {
@@ -25,8 +27,10 @@ describe('MixDatabaseDataRestClientService', () => {
     expect(api.get).toHaveBeenCalledWith('/mix-database-data/form/init/testdb');
   });
 
-  it('should throw if no mixDatabaseName for saveData', async () => {
-    await expect(clientService.saveData('', {})).rejects.toThrow('Missing mixDatabaseName');
+  it('should return error if no mixDatabaseName for saveData', async () => {
+    const result = await clientService.saveData('', {});
+    expect(result.isSucceed).toBe(false);
+    expect(result.errors).toContain('Missing mixDatabaseName');
   });
 
   it('should call saveData', async () => {
@@ -36,8 +40,10 @@ describe('MixDatabaseDataRestClientService', () => {
     expect(api.post).toHaveBeenCalledWith('/mix-database-data/form/save-data/testdb/true', { foo: 'bar' });
   });
 
-  it('should throw if no dataId for saveValues', async () => {
-    await expect(clientService.saveValues('', {})).rejects.toThrow('Missing dataId');
+  it('should return error if no dataId for saveValues', async () => {
+    const result = await clientService.saveValues('', {});
+    expect(result.isSucceed).toBe(false);
+    expect(result.errors).toContain('Missing dataId');
   });
 
   it('should call saveValues', async () => {

packages/database/tests/mix-database-data-rest-portal-service.test.ts

@@ -1,5 +1,5 @@
-import { ApiService } from './api-services';
-import { MixDatabaseDataRestPortalService } from './mix-database-data-rest-portal-service';
+import { ApiService } from '@mixcore/api';
+import { MixDatabaseDataRestPortalService } from '../src/mix-database-data-rest-portal-service';
 
 describe('MixDatabaseDataRestPortalService', () => {
   let api: ApiService;
@@ -35,8 +35,10 @@ describe('MixDatabaseDataRestPortalService', () => {
     expect(api.get).toHaveBeenCalledWith('/mix-database-data/portal/additional-data');
   });
 
-  it('should throw if no mixDatabaseName for initData', async () => {
-    await expect(portalService.initData('')).rejects.toThrow('Missing mixDatabaseName');
+  it('should return error if no mixDatabaseName for initData', async () => {
+    const result = await portalService.initData('');
+    expect(result.isSucceed).toBe(false);
+    expect(result.errors).toContain('Missing mixDatabaseName');
   });
 
   it('should call initData', async () => {
@@ -60,24 +62,31 @@ describe('MixDatabaseDataRestPortalService', () => {
     expect(api.get).toHaveBeenCalledWith('/mix-database-data/portal/export');
   });
 
-  it('should throw if no mixDatabaseName for import', async () => {
-    await expect(portalService.import('', new File([''], 'test.txt'))).rejects.toThrow('Missing mixDatabaseName');
+  it('should return error if no mixDatabaseName for import', async () => {
+    const result = await portalService.import('', new File([''], 'test.txt'));
+    expect(result.isSucceed).toBe(false);
+    expect(result.errors).toContain('Missing mixDatabaseName');
   });
 
-  it('should throw if no file for import', async () => {
-    await expect(portalService.import('testdb', null as any)).rejects.toThrow('Missing file');
+  it('should return error if no file for import', async () => {
+    const result = await portalService.import('testdb', null as any);
+    expect(result.isSucceed).toBe(false);
+    expect(result.errors).toContain('Missing file');
   });
 
   it('should call import', async () => {
     const fakeFile = new File(['test'], 'test.txt', { type: 'text/plain' });
     globalThis.fetch = jest.fn().mockResolvedValue({ ok: true, json: async () => ({ imported: true }) });
     const result = await portalService.import('testdb', fakeFile);
-    expect(result).toEqual({ imported: true });
+    expect(result.data).toEqual({ imported: true });
+    expect(result.isSucceed).toBe(true);
     expect(globalThis.fetch).toHaveBeenCalled();
   });
 
-  it('should throw if no mixDatabaseId for migrate', async () => {
-    await expect(portalService.migrate('')).rejects.toThrow('Missing mixDatabaseId');
+  it('should return error if no mixDatabaseId for migrate', async () => {
+    const result = await portalService.migrate('');
+    expect(result.isSucceed).toBe(false);
+    expect(result.errors).toContain('Missing mixDatabaseId');
   });
 
   it('should call migrate', async () => {

packages/database/tests/mix-database-data-value-rest-service.test.ts

@@ -1,5 +1,5 @@
-import { ApiService } from './api-services';
-import { MixDatabaseDataValueRestService } from './mix-database-data-value-rest-service';
+import { ApiService } from '@mixcore/api';
+import { MixDatabaseDataValueRestService } from '../src/mix-database-data-value-rest-service';
 
 describe('MixDatabaseDataValueRestService', () => {
   let api: ApiService;

packages/database/tests/module-data-rest-mvc-service.test.ts

@@ -1,5 +1,5 @@
-import { ApiService } from './api-services';
-import { ModuleDataRestMvcService } from './module-data-rest-mvc-service';
+import { ApiService } from '@mixcore/api';
+import { ModuleDataRestMvcService } from '../src/module-data-rest-mvc-service';
 
 describe('ModuleDataRestMvcService', () => {
   let api: ApiService;

packages/database/tests/module-data-services.test.ts

@@ -1,16 +1,33 @@
-import { ModuleDataService } from './module-data-services';
+import { ModuleDataService } from '../src/module-data-services';
+import { ApiService } from '@mixcore/api';
 
+const api = new ApiService({ apiBaseUrl: 'https://mixcore.net' });
 const config = {
   apiBaseUrl: 'https://mixcore.net',
+  api,
   apiKey: process.env.MIXCORE_API_KEY || '',
 };
 
 describe('ModuleDataService', () => {
   const service = new ModuleDataService(config);
 
+  beforeEach(() => {
+    // Mock API response to match ApiResult format expected by service
+    globalThis.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        items: []
+      })
+    });
+  });
+
   it('fetchDataItems should return an array', async () => {
-    const items = await service.fetchDataItems('1');
-    expect(Array.isArray(items)).toBe(true);
+    const result = await service.fetchDataItems('1');
+    console.log('Test result:', result);
+    expect(result).toBeDefined();
+    expect(result.data).toBeDefined();
+    expect(result.data.items).toBeDefined();
+    expect(Array.isArray(result.data.items)).toBe(true);
   });
 
   // Note: createDataItem and deleteDataItem require valid credentials and real data

packages/database/tests/related-attribute-data-rest-form-service.test.ts

@@ -1,8 +1,10 @@
-import { RelatedAttributeDataRestFormService } from './related-attribute-data-rest-form-service';
+import { RelatedAttributeDataRestFormService } from '../src/related-attribute-data-rest-form-service';
+import { ApiService } from '@mixcore/api';
 
 describe('RelatedAttributeDataRestFormService', () => {
   it('should instantiate with correct endpoint', () => {
-    const service = new RelatedAttributeDataRestFormService();
+    const api = new ApiService({ apiBaseUrl: 'http://localhost/api/' });
+    const service = new RelatedAttributeDataRestFormService(api);
     // @ts-expect-error endpoint is protected/private in base, this is a placeholder for real test
     expect(service.endpoint).toBe('mix-database-data-association/form');
   });

packages/database/tests/related-attribute-data-rest-portal-service.test.ts

@@ -3,7 +3,8 @@ import { ApiService } from '@mixcore/api';
 
 describe('RelatedAttributeDataRestPortalService', () => {
   it('should instantiate with correct endpoint', () => {
-    const service = new RelatedAttributeDataRestPortalService();
+    const api = new ApiService({ apiBaseUrl: 'http://localhost/api/' });
+    const service = new RelatedAttributeDataRestPortalService(api);
     // @ts-expect-error endpoint is protected/private in base, this is a placeholder for real test
     expect(service.endpoint).toBe('mix-database-data-association/portal');
   });