@finatic/client 0.0.139 → 0.0.141

package/src/mocks/MockFactory.ts

@@ -0,0 +1,97 @@
+import { ApiClient } from '../core/client/ApiClient';
+import { MockApiClient } from './MockApiClient';
+import { MockConfig } from './MockDataProvider';
+import { shouldUseMocks, shouldMockApiOnly, getMockConfig } from './utils';
+import { DeviceInfo } from '../types';
+
+/**
+ * Factory class for creating API clients (real or mock)
+ */
+export class MockFactory {
+  /**
+   * Create an API client based on environment configuration
+   * @param baseUrl - The base URL for the API
+   * @param deviceInfo - Optional device information
+   * @param mockConfig - Optional mock configuration (only used if mocks are enabled)
+   * @returns ApiClient or MockApiClient instance
+   */
+  static createApiClient(
+    baseUrl: string,
+    deviceInfo?: DeviceInfo,
+    mockConfig?: MockConfig
+  ): ApiClient | MockApiClient {
+    const useMocks = shouldUseMocks();
+    const mockApiOnly = shouldMockApiOnly();
+
+    if (useMocks || mockApiOnly) {
+      // Merge environment config with provided config
+      const envConfig = getMockConfig();
+      const finalConfig: MockConfig = {
+        delay: mockConfig?.delay || envConfig.delay,
+        scenario: mockConfig?.scenario || 'success',
+        customData: mockConfig?.customData || {},
+        mockApiOnly: mockApiOnly, // Pass this flag to the mock client
+      };
+
+      return new MockApiClient(baseUrl, deviceInfo, finalConfig);
+    } else {
+      return new ApiClient(baseUrl, deviceInfo);
+    }
+  }
+
+  /**
+   * Force create a mock API client regardless of environment settings
+   * @param baseUrl - The base URL for the API
+   * @param deviceInfo - Optional device information
+   * @param mockConfig - Optional mock configuration
+   * @returns MockApiClient instance
+   */
+  static createMockApiClient(
+    baseUrl: string,
+    deviceInfo?: DeviceInfo,
+    mockConfig?: MockConfig
+  ): MockApiClient {
+    return new MockApiClient(baseUrl, deviceInfo, mockConfig);
+  }
+
+  /**
+   * Force create a real API client regardless of environment settings
+   * @param baseUrl - The base URL for the API
+   * @param deviceInfo - Optional device information
+   * @returns ApiClient instance
+   */
+  static createRealApiClient(baseUrl: string, deviceInfo?: DeviceInfo): ApiClient {
+    return new ApiClient(baseUrl, deviceInfo);
+  }
+
+  /**
+   * Check if mocks are currently enabled
+   * @returns boolean indicating if mocks are enabled
+   */
+  static isMockMode(): boolean {
+    return shouldUseMocks();
+  }
+
+  /**
+   * Get current mock configuration
+   * @returns Mock configuration object
+   */
+  static getMockConfig(): { enabled: boolean; delay?: number } {
+    return getMockConfig();
+  }
+}
+
+/**
+ * Convenience function to create an API client
+ * @param baseUrl - The base URL for the API
+ * @param deviceInfo - Optional device information
+ * @param mockConfig - Optional mock configuration
+ * @returns ApiClient or MockApiClient instance
+ */
+export function createMockApiClient(
+  baseUrl: string,
+  deviceInfo?: DeviceInfo,
+  mockConfig?: MockConfig
+): ApiClient | MockApiClient {
+  return MockFactory.createApiClient(baseUrl, deviceInfo, mockConfig);
+}

package/src/mocks/utils.ts

@@ -0,0 +1,133 @@
+/**
+ * Utility functions for mock system environment detection
+ */
+
+// Type declarations for Node.js environment
+// Note: process is already declared globally in Node.js types
+
+/**
+ * Check if mocks should be used based on environment variables
+ * Supports both browser and Node.js environments
+ */
+export function shouldUseMocks(): boolean {
+  // Check Node.js environment
+  if (typeof process !== 'undefined' && process?.env) {
+    return (
+      process.env.FINATIC_USE_MOCKS === 'true' ||
+      process.env.NEXT_PUBLIC_FINATIC_USE_MOCKS === 'true'
+    );
+  }
+
+  // Check browser environment
+  if (typeof window !== 'undefined') {
+    // Check global variable
+    if ((window as any).FINATIC_USE_MOCKS === 'true') {
+      return true;
+    }
+
+    // Check Next.js public environment variables
+    if ((window as any).NEXT_PUBLIC_FINATIC_USE_MOCKS === 'true') {
+      return true;
+    }
+
+    // Check localStorage
+    try {
+      return localStorage.getItem('FINATIC_USE_MOCKS') === 'true';
+    } catch (error) {
+      // localStorage might not be available
+      return false;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Set mock mode in the current environment
+ */
+export function setMockMode(enabled: boolean): void {
+  // Set in Node.js environment
+  if (typeof process !== 'undefined' && process?.env) {
+    process.env.FINATIC_USE_MOCKS = enabled ? 'true' : 'false';
+  }
+
+  // Set in browser environment
+  if (typeof window !== 'undefined') {
+    (window as any).FINATIC_USE_MOCKS = enabled ? 'true' : 'false';
+
+    try {
+      if (enabled) {
+        localStorage.setItem('FINATIC_USE_MOCKS', 'true');
+      } else {
+        localStorage.removeItem('FINATIC_USE_MOCKS');
+      }
+    } catch (error) {
+      // localStorage might not be available
+    }
+  }
+}
+
+/**
+ * Check if only API should be mocked (but portal should use real URL)
+ */
+export function shouldMockApiOnly(): boolean {
+  // Check Node.js environment
+  if (typeof process !== 'undefined' && process?.env) {
+    return (
+      process.env.FINATIC_MOCK_API_ONLY === 'true' ||
+      process.env.NEXT_PUBLIC_FINATIC_MOCK_API_ONLY === 'true'
+    );
+  }
+
+  // Check browser environment
+  if (typeof window !== 'undefined') {
+    // Check global variable
+    if ((window as any).FINATIC_MOCK_API_ONLY === 'true') {
+      return true;
+    }
+
+    // Check Next.js public environment variables
+    if ((window as any).NEXT_PUBLIC_FINATIC_MOCK_API_ONLY === 'true') {
+      return true;
+    }
+
+    // Check localStorage
+    try {
+      return localStorage.getItem('FINATIC_MOCK_API_ONLY') === 'true';
+    } catch (error) {
+      // localStorage might not be available
+      return false;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Get mock configuration from environment
+ */
+export function getMockConfig(): { enabled: boolean; delay?: number; mockApiOnly?: boolean } {
+  const enabled = shouldUseMocks();
+  const mockApiOnly = shouldMockApiOnly();
+
+  let delay: number | undefined;
+
+  // Check for custom delay in Node.js
+  if (typeof process !== 'undefined' && process?.env?.FINATIC_MOCK_DELAY) {
+    delay = parseInt(process.env.FINATIC_MOCK_DELAY, 10);
+  }
+
+  // Check for custom delay in browser
+  if (typeof window !== 'undefined') {
+    try {
+      const storedDelay = localStorage.getItem('FINATIC_MOCK_DELAY');
+      if (storedDelay) {
+        delay = parseInt(storedDelay, 10);
+      }
+    } catch (error) {
+      // localStorage might not be available
+    }
+  }
+
+  return { enabled, delay, mockApiOnly };
+}