@amaster.ai/client 1.1.0-beta.4 → 1.1.0-beta.41

package/types/__tests__/type-checks.test-d.ts

@@ -0,0 +1,163 @@
+/**
+ * Type-level tests for @amaster.ai/client
+ * 
+ * These tests verify type inference and type safety at compile time.
+ * They ensure that the type definitions work correctly with TypeScript.
+ */
+
+import { describe, it, expectTypeOf } from 'vitest';
+import type {
+  AmasterClient,
+  AmasterClientOptions,
+  ClientResult,
+  ClientError,
+  EntityListResponse,
+  LoginParams,
+  User,
+  Task,
+  ProcessInstance,
+} from '../index';
+
+describe('Type Tests', () => {
+  describe('ClientResult', () => {
+    it('should have correct structure', () => {
+      type Result = ClientResult<{ id: number; name: string }>;
+      
+      expectTypeOf<Result>().toMatchTypeOf<{
+        data: { id: number; name: string } | null;
+        error: ClientError | null;
+        status: number;
+        success: boolean;
+      }>();
+    });
+
+    it('should infer data type correctly', () => {
+      type UserResult = ClientResult<User>;
+      
+      expectTypeOf<UserResult['data']>().toEqualTypeOf<User | null>();
+    });
+
+    it('should have success field', () => {
+      type Result = ClientResult<unknown>;
+      
+      expectTypeOf<Result['success']>().toEqualTypeOf<boolean>();
+    });
+  });
+
+  describe('ClientError', () => {
+    it('should have all required fields', () => {
+      expectTypeOf<ClientError>().toMatchTypeOf<{
+        status: number;
+        message: string;
+        code?: string;
+        details?: unknown;
+        timestamp?: string;
+      }>();
+    });
+  });
+
+  describe('EntityListResponse', () => {
+    it('should infer item type correctly', () => {
+      type UserListResponse = EntityListResponse<{ id: number; name: string }>;
+      
+      expectTypeOf<UserListResponse['items']>().toEqualTypeOf<Array<{ id: number; name: string }>>();
+    });
+
+    it('should have pagination fields', () => {
+      type Response = EntityListResponse<unknown>;
+      
+      expectTypeOf<Response>().toMatchTypeOf<{
+        items: unknown[];
+        total: number;
+        page?: number;
+        perPage?: number;
+      }>();
+    });
+  });
+
+  describe('AmasterClient', () => {
+    it('should have all service modules', () => {
+      expectTypeOf<AmasterClient>().toHaveProperty('auth');
+      expectTypeOf<AmasterClient>().toHaveProperty('entity');
+      expectTypeOf<AmasterClient>().toHaveProperty('bpm');
+      expectTypeOf<AmasterClient>().toHaveProperty('workflow');
+      expectTypeOf<AmasterClient>().toHaveProperty('asr');
+      expectTypeOf<AmasterClient>().toHaveProperty('copilot');
+      expectTypeOf<AmasterClient>().toHaveProperty('function');
+      expectTypeOf<AmasterClient>().toHaveProperty('tts');
+      expectTypeOf<AmasterClient>().toHaveProperty('s3');
+    });
+
+    it('should have utility methods', () => {
+      expectTypeOf<AmasterClient>().toHaveProperty('isAuthenticated');
+      expectTypeOf<AmasterClient>().toHaveProperty('getAccessToken');
+      expectTypeOf<AmasterClient>().toHaveProperty('setAccessToken');
+      expectTypeOf<AmasterClient>().toHaveProperty('clearAuth');
+    });
+  });
+
+  describe('LoginParams', () => {
+    it('should accept email login', () => {
+      const params: LoginParams = {
+        email: 'user@example.com',
+        password: 'password123'
+      };
+      
+      expectTypeOf(params).toMatchTypeOf<LoginParams>();
+    });
+
+    it('should accept username login', () => {
+      const params: LoginParams = {
+        username: 'johndoe',
+        password: 'password123'
+      };
+      
+      expectTypeOf(params).toMatchTypeOf<LoginParams>();
+    });
+
+    it('should accept phone login', () => {
+      const params: LoginParams = {
+        phone: '+1234567890',
+        password: 'password123'
+      };
+      
+      expectTypeOf(params).toMatchTypeOf<LoginParams>();
+    });
+  });
+
+  describe('Generic Type Inference', () => {
+    it('should infer entity list result type', () => {
+      type User = { id: number; name: string; email: string };
+      type Result = ClientResult<EntityListResponse<User>>;
+      
+      // If success, data.items should be User[]
+      expectTypeOf<NonNullable<Result['data']>['items']>().toEqualTypeOf<User[]>();
+    });
+
+    it('should infer entity get result type', () => {
+      type Product = { id: number; title: string; price: number };
+      type Result = ClientResult<Product>;
+      
+      expectTypeOf<NonNullable<Result['data']>>().toEqualTypeOf<Product>();
+    });
+  });
+
+  describe('BPM Types', () => {
+    it('should have correct Task structure', () => {
+      expectTypeOf<Task>().toMatchTypeOf<{
+        id: string;
+        name: string;
+        assignee: string | null;
+        processInstanceId: string;
+      }>();
+    });
+
+    it('should have correct ProcessInstance structure', () => {
+      expectTypeOf<ProcessInstance>().toMatchTypeOf<{
+        id: string;
+        definitionId?: string;
+        businessKey?: string;
+      }>();
+    });
+  });
+});

package/types/asr.d.ts

@@ -1,31 +1,12 @@
 /**
- * ============================================================================
- * ASR (Automatic Speech Recognition) - Type Definitions
- * ============================================================================
- * 
- * Real-time speech recognition using WebSocket connection.
+ *  * Real-time speech recognition using WebSocket connection.
  * 
  * @module asr
  */
 
 /**
  * ASR Client Configuration
- * 
- * @example
- * Configure ASR with custom voice settings:
- * ```typescript
- * const client = createClient({ baseURL: 'https://api.amaster.ai' });
- * 
- * // Reconfigure ASR client
- * client.asr = createASRClient({
- *   audioFormat: 'pcm16',
- *   sampleRate: 16000,
- *   onTranscript: (text, isFinal) => {
- *     console.log(isFinal ? `Final: ${text}` : `Interim: ${text}`);
- *   },
- *   onError: (error) => console.error('ASR Error:', error)
- * });
- * ```
+ *
  */
 export interface ASRClientConfig {
   /** Audio format, default 'pcm16' */
@@ -61,78 +42,20 @@ export interface ASRClientConfig {
 }
 
 /**
- * ASR Client API
- * 
- * Real-time speech recognition client using WebSocket.
- * 
- * @example
- * Basic usage:
- * ```typescript
- * const client = createClient({ baseURL: 'https://api.amaster.ai' });
- * 
- * // Configure callbacks
- * client.asr = createASRClient({
- *   onTranscript: (text, isFinal) => {
- *     if (isFinal) {
- *       console.log('Final transcript:', text);
- *     } else {
- *       console.log('Interim transcript:', text);
- *     }
- *   }
- * });
- * 
- * // Connect and start recording
- * await client.asr.connect();
- * await client.asr.startRecording();
+ * ASR (Automatic Speech Recognition) Client API
  * 
- * // Stop recording
- * client.asr.stopRecording();
+ * Provides real-time speech-to-text conversion via WebSocket.
  * 
- * // Close connection
- * client.asr.close();
- * ```
- * 
- * @example
- * With error handling:
- * ```typescript
- * const client = createClient({ baseURL: 'https://api.amaster.ai' });
- * 
- * client.asr = createASRClient({
- *   onReady: () => console.log('ASR ready'),
- *   onSpeechStart: () => console.log('Speech detected'),
- *   onSpeechEnd: () => console.log('Speech ended'),
- *   onTranscript: (text, isFinal) => {
- *     console.log(isFinal ? `[FINAL] ${text}` : `[INTERIM] ${text}`);
- *   },
- *   onError: (error) => {
- *     console.error('ASR Error:', error.message);
- *   },
- *   onClose: () => {
- *     console.log('ASR connection closed');
- *   }
- * });
- * 
- * try {
- *   await client.asr.connect();
- *   await client.asr.startRecording();
- * } catch (error) {
- *   console.error('Failed to start ASR:', error);
- * }
- * ```
+ * @since 1.0.0
  */
-export interface ASRClient {
+export interface ASRClientAPI {
   /**
    * Connect to ASR service
    * 
    * Establishes WebSocket connection to the speech recognition service.
    * 
    * @returns Promise that resolves when connected
-   * 
-   * @example
-   * ```typescript
-   * await client.asr.connect();
-   * console.log('Connected to ASR service');
-   * ```
+   *
    */
   connect(): Promise<void>;
 
@@ -143,19 +66,7 @@ export interface ASRClient {
    * Requires microphone permission from the user.
    * 
    * @returns Promise that resolves when recording starts
-   * 
-   * @example
-   * ```typescript
-   * // Request microphone permission and start recording
-   * try {
-   *   await client.asr.startRecording();
-   *   console.log('Recording started');
-   * } catch (error) {
-   *   if (error.name === 'NotAllowedError') {
-   *     console.error('Microphone permission denied');
-   *   }
-   * }
-   * ```
+   *
    */
   startRecording(): Promise<void>;
 
@@ -163,16 +74,7 @@ export interface ASRClient {
    * Stop recording
    * 
    * Stops capturing audio from the microphone but keeps the WebSocket connection open.
-   * 
-   * @example
-   * ```typescript
-   * // Stop recording after 10 seconds
-   * await client.asr.startRecording();
-   * setTimeout(() => {
-   *   client.asr.stopRecording();
-   *   console.log('Recording stopped');
-   * }, 10000);
-   * ```
+   *
    */
   stopRecording(): void;
 
@@ -180,13 +82,7 @@ export interface ASRClient {
    * Close connection
    * 
    * Closes the WebSocket connection and releases resources.
-   * 
-   * @example
-   * ```typescript
-   * // Cleanup when done
-   * client.asr.stopRecording();
-   * client.asr.close();
-   * ```
+   *
    */
   close(): void;
 }

package/types/auth/code-auth.d.ts

@@ -1,9 +1,5 @@
 /**
- * ============================================================================
- * Verification Code Authentication - Type Definitions
- * ============================================================================
- * 
- * Verification code-based authentication including:
+ *  * Verification code-based authentication including:
  * - Email verification code login
  * - SMS verification code login
  * - Send verification code
@@ -24,46 +20,7 @@ export type CodeLoginType = 'email' | 'phone';
 
 /**
  * Verification code login parameters
- * 
- * @example
- * Email code login:
- * ```typescript
- * // 1. Send verification code
- * await client.auth.sendCode({
- *   type: 'email',
- *   email: 'user@example.com'
- * });
- * 
- * // 2. User receives code via email: "123456"
- * 
- * // 3. Login with code
- * const result = await client.auth.codeLogin({
- *   email: 'user@example.com',
- *   code: '123456'
- * });
- * 
- * if (result.data) {
- *   console.log('Logged in successfully!');
- * }
- * ```
- * 
- * @example
- * Phone code login:
- * ```typescript
- * // 1. Send SMS code
- * await client.auth.sendCode({
- *   type: 'phone',
- *   phone: '+86-13800138000'
- * });
- * 
- * // 2. User receives SMS: "654321"
- * 
- * // 3. Login with code
- * await client.auth.codeLogin({
- *   phone: '+86-13800138000',
- *   code: '654321'
- * });
- * ```
+ *
  */
 export interface CodeLoginParams {
   /** Login method (optional, auto-detected) */
@@ -119,45 +76,7 @@ export interface CodeAuthAPI {
    * 
    * @param params - Email/phone and verification code
    * @returns User info and access token
-   * 
-   * @example
-   * Complete code login flow:
-   * ```typescript
-   * // 1. Send verification code
-   * await client.auth.sendCode({
-   *   type: 'email',
-   *   email: 'user@example.com'
-   * });
-   * 
-   * // 2. User receives code: "123456"
-   * 
-   * // 3. Login with code
-   * const result = await client.auth.codeLogin({
-   *   email: 'user@example.com',
-   *   code: '123456'
-   * });
-   * 
-   * if (result.data) {
-   *   console.log('Logged in successfully!');
-   * }
-   * ```
-   * 
-   * @example
-   * SMS code login with error handling:
-   * ```typescript
-   * const result = await client.auth.codeLogin({
-   *   phone: '+86-13800138000',
-   *   code: userInputCode
-   * });
-   * 
-   * if (result.error) {
-   *   if (result.status === 400) {
-   *     console.error('Invalid or expired code');
-   *   } else {
-   *     console.error('Login failed:', result.error.message);
-   *   }
-   * }
-   * ```
+   *
    */
   codeLogin(params: CodeLoginParams): Promise<ClientResult<LoginResponse>>;
 
@@ -169,43 +88,7 @@ export interface CodeAuthAPI {
    * 
    * @param params - Email or phone to send code to
    * @returns Success status
-   * 
-   * @example
-   * Send email verification code:
-   * ```typescript
-   * const result = await client.auth.sendCode({
-   *   type: 'email',
-   *   email: 'user@example.com'
-   * });
-   * 
-   * if (result.data?.success) {
-   *   console.log('Code sent to email');
-   *   showCodeInputForm();
-   * }
-   * ```
-   * 
-   * @example
-   * Send SMS verification code:
-   * ```typescript
-   * await client.auth.sendCode({
-   *   type: 'phone',
-   *   phone: '+86-13800138000'
-   * });
-   * console.log('SMS sent');
-   * ```
-   * 
-   * @example
-   * With rate limiting handling:
-   * ```typescript
-   * const result = await client.auth.sendCode({
-   *   type: 'email',
-   *   email: 'user@example.com'
-   * });
-   * 
-   * if (result.status === 429) {
-   *   console.error('Too many requests. Please try again later.');
-   * }
-   * ```
+   *
    */
   sendCode(params: SendCodeParams): Promise<ClientResult<SuccessResponse>>;
 
@@ -216,39 +99,7 @@ export interface CodeAuthAPI {
    * Used during registration or sensitive operations.
    * 
    * @returns Captcha ID and image (base64)
-   * 
-   * @example
-   * Display captcha to user:
-   * ```typescript
-   * const result = await client.auth.getCaptcha();
-   * if (result.data) {
-   *   // Display image to user
-   *   const img = document.createElement('img');
-   *   img.src = result.data.captchaImage;
-   *   document.body.appendChild(img);
-   *   
-   *   // Save captchaId for later verification
-   *   const captchaId = result.data.captchaId;
-   * }
-   * ```
-   * 
-   * @example
-   * Use with registration:
-   * ```typescript
-   * // 1. Get captcha
-   * const captchaResult = await client.auth.getCaptcha();
-   * showCaptchaImage(captchaResult.data.captchaImage);
-   * 
-   * // 2. Get user input
-   * const userInput = await promptUserForCaptcha();
-   * 
-   * // 3. Register with captcha
-   * await client.auth.register({
-   *   email: 'user@example.com',
-   *   password: 'Password@123',
-   *   captcha: `${captchaResult.data.captchaId}:${userInput}`
-   * });
-   * ```
+   *
    */
   getCaptcha(): Promise<ClientResult<CaptchaResponse>>;
 }