feat: Enhance CommonService with new methods and improve test coverage for UserServices and BaseService

Author: Smilefounder

.github/instructions/general.instructions.md

@@ -59,7 +59,7 @@ mixcore/javascript-sdk/
 
 ### Extraction & Refactoring Requirements
 
-- Audit and extract all shared, base, and API code from `.legacy` (legacy portal) into the correct domain-driven package.
+- Audit and extract all shared, base, and API code from `/.legacy` (legacy portal) into the correct domain-driven package.
 - Exclude all SPA/UI-coupled logic (routing, DOM, framework state, etc.).
 - Refactor all imports/exports to use package-relative paths.
 - Remove or abstract any SPA-coupled dependencies (e.g., window, document, SPA-specific stores).

packages/base/tests/base-service.test.ts

@@ -0,0 +1,35 @@
+import { BaseService, BaseServiceConfig } from '../src/base-service';
+
+class TestService extends BaseService {
+  constructor(config: BaseServiceConfig) {
+    super(config);
+  }
+
+  public handleError(error: Error): void {
+    console.error('TestService error:', error);
+  }
+}
+
+describe('BaseService', () => {
+  const config: BaseServiceConfig = {
+    apiBaseUrl: 'https://api.example.com',
+    getApiResult: jest.fn().mockResolvedValue({}),
+    getRestApiResult: jest.fn().mockResolvedValue({}),
+    getAnonymousApiResult: jest.fn().mockResolvedValue({}),
+  };
+
+  const service = new TestService(config);
+
+  it('should instantiate with config', () => {
+    expect(service).toBeInstanceOf(TestService);
+    expect(service['config']).toEqual(config);
+  });
+
+  it('should handle errors', () => {
+    const mockError = new Error('Test error');
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    
+    expect(() => service.handleError(mockError)).not.toThrow();
+    expect(console.error).toHaveBeenCalledWith('TestService error:', mockError);
+  });
+});

packages/shared/src/common-services.test.ts

@@ -19,4 +19,37 @@ describe('CommonService', () => {
     await service.showAlertMsg('Title', 'Message');
     expect(config.onAlert).toHaveBeenCalledWith('Title', 'Message');
   });
+
+  it('sendMail should call getApiResult', async () => {
+    await service.sendMail('Subject', 'Body');
+    expect(config.getApiResult).toHaveBeenCalledWith({
+      method: 'POST',
+      url: '/portal/sendmail',
+      data: { subject: 'Subject', body: 'Body' }
+    });
+  });
+
+  it('getAllSettings should call getRestApiResult', async () => {
+    await service.getAllSettings('en-US');
+    expect(config.getRestApiResult).toHaveBeenCalledWith({
+      method: 'GET',
+      url: '/rest/shared/en-US/get-shared-settings'
+    }, false, true);
+  });
+
+  it('generateSitemap should call getApiResult', async () => {
+    await service.generateSitemap();
+    expect(config.getApiResult).toHaveBeenCalledWith({
+      method: 'GET',
+      url: '/portal/sitemap'
+    });
+  });
+
+  it('getPermissions should call getRestApiResult', async () => {
+    await service.getPermissions();
+    expect(config.getRestApiResult).toHaveBeenCalledWith({
+      method: 'GET',
+      url: '/rest/shared/permissions'
+    });
+  });
 });

packages/shared/src/common-services.ts

@@ -2,9 +2,27 @@
 /**
  * CommonService: Framework-agnostic utility for Mixcore SDK
  * All SPA/Angular dependencies removed. Configuration must be injected.
- *
- * TODO: Implement actual logic and types for each method.
  */
+
+interface ApiResponse {
+  isSucceed: boolean;
+  data?: any;
+  message?: string;
+}
+
+interface SharedSettings {
+  [key: string]: any;
+  culture?: string;
+}
+
+interface SitemapResult {
+  urls: string[];
+  generatedAt: string;
+}
+
+interface PermissionSet {
+  [permission: string]: boolean;
+}
 export interface CommonServiceConfig {
   apiBaseUrl: string;
   getApiResult: (req: any) => Promise<any>;
@@ -63,17 +81,26 @@ export class CommonService {
     return validExts.includes(ext);
   }
 
-  async sendMail(subject: string, body: string): Promise<any> {
-    // TODO: Implement using config.getApiResult
+  /**
+   * Sends an email using the configured API endpoint
+   * @param subject - Email subject
+   * @param body - Email body content
+   * @returns Promise with API response
+   */
+  async sendMail(subject: string, body: string): Promise<ApiResponse> {
     return this.config.getApiResult({
       method: 'POST',
       url: '/portal/sendmail',
       data: { subject, body }
     });
   }
 
-  async getAllSettings(culture?: string): Promise<any> {
-    // TODO: Implement using config.getRestApiResult
+  /**
+   * Gets all shared settings, optionally filtered by culture
+   * @param culture - Optional culture code to filter settings
+   * @returns Promise with settings data
+   */
+  async getAllSettings(culture?: string): Promise<SharedSettings> {
     let url = '/rest/shared';
     if (culture) url += `/${culture}`;
     url += '/get-shared-settings';
@@ -83,16 +110,22 @@ export class CommonService {
     }, false, true);
   }
 
-  async genrateSitemap(): Promise<any> {
-    // TODO: Implement using config.getApiResult
+  /**
+   * Generates a sitemap using the portal API
+   * @returns Promise with sitemap generation result
+   */
+  async generateSitemap(): Promise<SitemapResult> {
     return this.config.getApiResult({
       method: 'GET',
       url: '/portal/sitemap'
     });
   }
 
-  async getPermissions(): Promise<any> {
-    // TODO: Implement using config.getRestApiResult
+  /**
+   * Gets user permissions from the API
+   * @returns Promise with permissions data
+   */
+  async getPermissions(): Promise<PermissionSet> {
     return this.config.getRestApiResult({
       method: 'GET',
       url: '/rest/shared/permissions'

packages/user/tests/user-services.test.ts

@@ -1,5 +1,5 @@
-import { ApiService } from './src/api-services';
-import { UserServices } from './src/user-services';
+import { ApiService } from '@mixcore/api';
+import { UserServices } from '../src/user-services';
 
 describe('UserServices', () => {
   let api: ApiService;
@@ -15,7 +15,6 @@ describe('UserServices', () => {
   });
 
   it('should call getMyProfile', async () => {
-    // Mock fetch
     globalThis.fetch = jest.fn().mockResolvedValue({ ok: true, json: async () => ({ id: 'me' }) });
     const result = await userServices.getMyProfile();
     expect(result).toEqual({ id: 'me' });
@@ -27,5 +26,45 @@ describe('UserServices', () => {
     expect(result).toEqual({ success: true });
   });
 
-  // Add more tests for other methods as needed
+  it('should call register', async () => {
+    globalThis.fetch = jest.fn().mockResolvedValue({ ok: true, json: async () => ({ id: 'new' }) });
+    const result = await userServices.register({ name: 'New User' });
+    expect(result).toEqual({ id: 'new' });
+  });
+
+  it('should call getUser', async () => {
+    globalThis.fetch = jest.fn().mockResolvedValue({ ok: true, json: async () => ({ id: '123' }) });
+    const result = await userServices.getUser('123', 'basic');
+    expect(result).toEqual({ id: '123' });
+  });
+
+  it('should call getUsers', async () => {
+    globalThis.fetch = jest.fn().mockResolvedValue({ ok: true, json: async () => ({ users: [] }) });
+    const result = await userServices.getUsers({ page: 1 });
+    expect(result).toEqual({ users: [] });
+  });
+
+  it('should call importUsers', async () => {
+    globalThis.fetch = jest.fn().mockResolvedValue({ ok: true, json: async () => ({ imported: 5 }) });
+    const result = await userServices.importUsers('base64data');
+    expect(result).toEqual({ imported: 5 });
+  });
+
+  it('should call removeUser', async () => {
+    globalThis.fetch = jest.fn().mockResolvedValue({ ok: true, json: async () => ({ success: true }) });
+    const result = await userServices.removeUser('123');
+    expect(result).toEqual({ success: true });
+  });
+
+  it('should call updateRoleStatus', async () => {
+    globalThis.fetch = jest.fn().mockResolvedValue({ ok: true, json: async () => ({ updated: true }) });
+    const result = await userServices.updateRoleStatus({ userId: '1', roleId: 'admin' });
+    expect(result).toEqual({ updated: true });
+  });
+
+  it('should call getUserDemographicInfo', async () => {
+    globalThis.fetch = jest.fn().mockResolvedValue({ ok: true, json: async () => ({ info: {} }) });
+    const result = await userServices.getUserDemographicInfo();
+    expect(result).toEqual({ info: {} });
+  });
 });