@dbs-portal/core-api
Version:
HTTP client and API utilities for DBS Portal
198 lines • 5.83 kB
JavaScript
/**
* MSW integration with existing ApiClient and factory patterns
*/
import { isMockingEnabled, getMockingMode } from '../config/environment';
import { setupMocks } from '../setup';
import { updateMockConfig } from '../config';
const { VITE_NODE_ENV: NODE_ENV } = import.meta.env;
/**
* Create API client configuration with MSW integration
*/
export function createMockAwareConfig(options) {
const shouldMock = options.enableMocking ?? isMockingEnabled();
const mockMode = getMockingMode();
// Base configuration
const config = {
baseURL: shouldMock ? (options.mockBaseURL || options.baseURL) : options.baseURL,
...options.clientConfig,
};
// Add MSW configuration if mocking is enabled
if (shouldMock) {
config.mocking = {
enabled: true,
mode: mockMode,
baseUrl: options.mockBaseURL || options.baseURL,
...options.mockConfig,
};
config.mockHandlers = options.mockHandlers || [];
config.autoSetupMocks = true;
}
return config;
}
/**
* Create environment-aware API client configuration
*/
export function createEnvironmentAwareConfig(config) {
const env = NODE_ENV || 'development';
const mockMode = getMockingMode();
let envConfig;
let shouldMock = false;
switch (env) {
case 'production':
envConfig = config.production;
shouldMock = false;
break;
case 'test':
envConfig = config.testing;
shouldMock = envConfig.enableMocking ?? true;
break;
case 'development':
default:
if (mockMode === 'storybook' && config.storybook) {
envConfig = config.storybook;
shouldMock = envConfig.enableMocking ?? true;
}
else {
envConfig = config.development;
shouldMock = envConfig.enableMocking ?? isMockingEnabled();
}
break;
}
const clientConfig = {
baseURL: envConfig.baseURL,
...envConfig.config,
};
if (shouldMock) {
clientConfig.mocking = {
enabled: true,
mode: mockMode,
baseUrl: envConfig.baseURL,
...envConfig.mockConfig,
};
clientConfig.mockHandlers = envConfig.mockHandlers || [];
clientConfig.autoSetupMocks = true;
}
return clientConfig;
}
/**
* Initialize MSW for API client if configured
*/
export async function initializeMockingForClient(config) {
if (!config.mocking?.enabled || !config.autoSetupMocks) {
return;
}
// Update global mock configuration
updateMockConfig(config.mocking);
// Setup MSW with custom handlers
const setupOptions = {
config: config.mocking,
handlers: config.mockHandlers || [],
start: true,
};
await setupMocks(setupOptions);
}
/**
* API client wrapper that handles MSW integration
*/
export class MockAwareApiClient {
client;
mockConfig;
isMockingEnabled;
constructor(client, config) {
this.client = client;
this.mockConfig = { ...config?.mocking };
this.isMockingEnabled = config?.mocking?.enabled ?? false;
// Initialize mocking if configured
if (config?.autoSetupMocks && this.isMockingEnabled) {
this.initializeMocking(config).catch(error => {
console.error('Failed to initialize MSW for API client:', error);
});
}
}
/**
* Get the underlying API client
*/
getClient() {
return this.client;
}
/**
* Check if mocking is enabled
*/
isMocking() {
return this.isMockingEnabled;
}
/**
* Get mock configuration
*/
getMockConfig() {
return this.mockConfig;
}
/**
* Enable mocking at runtime
*/
async enableMocking(handlers) {
if (this.isMockingEnabled) {
return;
}
const config = this.mockConfig || { enabled: true, mode: getMockingMode() };
await setupMocks({
config,
handlers: handlers || [],
start: true,
});
this.isMockingEnabled = true;
}
/**
* Disable mocking at runtime
*/
async disableMocking() {
if (!this.isMockingEnabled) {
return;
}
// This would require teardown functionality
// For now, we'll just mark as disabled
this.isMockingEnabled = false;
}
/**
* Add mock handlers at runtime
*/
addMockHandlers(..._handlers) {
if (!this.isMockingEnabled) {
console.warn('Cannot add mock handlers: mocking is not enabled');
return;
}
// This would use the MSW instance to add handlers
// Implementation depends on the setup
}
async initializeMocking(config) {
await initializeMockingForClient(config);
}
}
/**
* Utility to check if current environment should use mocking
*/
export function shouldUseMocking(options) {
if (options?.forceDisable)
return false;
if (options?.forceEnable)
return true;
const env = options?.environment || NODE_ENV || 'development';
switch (env) {
case 'production':
return false;
case 'test':
return true;
case 'development':
return isMockingEnabled();
default:
return false;
}
}
/**
* Get appropriate base URL based on mocking status
*/
export function getApiBaseUrl(options) {
const shouldMock = options.enableMocking ?? shouldUseMocking();
return shouldMock ? (options.mockBaseURL || options.realBaseURL) : options.realBaseURL;
}
//# sourceMappingURL=api-client-integration.js.map