@arc-js/config-manager 0.0.1 → 0.0.3

package/README.md

@@ -114,7 +114,7 @@ src/
 // main.tsx
 import React from 'react';
 import ReactDOM from 'react-dom/client';
-import { ConfigProvider } from '@arc-js/config-manager';
+import { ConfigManagerProvider } from '@arc-js/config-manager';
 
 const App = () => {
   return (
@@ -126,9 +126,9 @@ const App = () => {
 
 ReactDOM.createRoot(document.getElementById('root')!).render(
   <React.StrictMode>
-    <ConfigProvider preloadModules={['admin', 'dashboard']}>
+    <ConfigManagerProvider configs={{ base: {}, modules: {} }}>
       <App />
-    </ConfigProvider>
+    </ConfigManagerProvider>
   </React.StrictMode>
 );
 ```
@@ -144,181 +144,105 @@ const MyComponent = () => {
   const config = useConfig('admin'); // Optionnel: nom du module
 
   // Récupérer une valeur avec chemin pointé
-  const appName = config.get('app.name');
-  const apiTimeout = config.get('api.timeout');
+  const appName = config.cf('app.name');
+  const apiTimeout = config.cf('api.timeout');
   
   // Récupérer avec valeur par défaut
-  const debugMode = config.get('app.debug', { defaultValue: false });
+  const debugMode = config.cf('app.debug', { defaultValue: false });
   
-  // Récupérer ou lancer une exception si non trouvé
-  const baseUrl = config.getOrThrow('api.baseUrl');
+  // Récupérer toute la configuration du module
+  const adminConfig = config.getConfig('admin');
   
-  // Vérifier l'existence d'un chemin
-  const hasAnalytics = config.has('app.features.analytics');
+  // Vérifier si le module est chargé
+  const isModuleLoaded = config.isModuleLoaded;
   
-  // Récupérer toutes les configurations
-  const allConfigs = config.getAll();
-  
-  // Accès aux variables d'environnement
-  const nodeEnv = config.getEnv('NODE_ENV');
-  const apiUrl = config.getEnv('apiUrl'); // VITE_API_URL
+  // Recharger les configurations
+  const handleReload = () => config.reloadConfig();
   
   return (
     <div>
       <h1>{appName}</h1>
       <p>API Timeout: {apiTimeout}ms</p>
-      <p>Environment: {nodeEnv}</p>
+      <p>Module chargé: {isModuleLoaded ? 'Oui' : 'Non'}</p>
+      <button onClick={handleReload}>Recharger la configuration</button>
     </div>
   );
 };
 ```
 
-### Hook useConfigValue (Typé)
+## 🛠️ Configuration du Provider
 
 ```typescript
-import { useConfigValue } from '@arc-js/config-manager';
-
-const FeatureToggle = () => {
-  const { value: isEnabled, isLoading, exists } = 
-    useConfigValue<boolean>('app.features.analytics', {
-      moduleName: 'admin',
-      defaultValue: false
-    });
-
-  if (isLoading) return <div>Chargement...</div>;
-  
-  return (
-    <div>
-      <p>Analytics: {isEnabled ? 'Activé' : 'Désactivé'}</p>
-      <p>Configuration existante: {exists ? 'Oui' : 'Non'}</p>
-    </div>
-  );
+// App.tsx
+import { ConfigManagerProvider } from '@arc-js/config-manager';
+
+// Configuration avec chargeurs dynamiques
+const configs = {
+  base: {
+    main: async () => (await import('./config.json')).default,
+    env: async () => ({ 
+      apiUrl: import.meta.env.VITE_API_URL,
+      nodeEnv: import.meta.env.NODE_ENV 
+    })
+  },
+  modules: {
+    admin: async () => (await import('./modules/admin/config.json')).default,
+    dashboard: async () => (await import('./modules/dashboard/config.json')).default
+  }
 };
-```
-
-### Modifier une configuration
 
-```typescript
-const SettingsPanel = () => {
-  const config = useConfig();
-  
-  const toggleDebug = () => {
-    const currentDebug = config.get('app.debug', { defaultValue: false });
-    config.set('app.debug', !currentDebug);
-  };
-  
-  const updateApiConfig = () => {
-    config.merge({
-      api: {
-        timeout: 60000,
-        retryAttempts: 5
-      }
-    }, 'admin'); // Appliquer uniquement au module admin
-  };
-  
+const App = () => {
   return (
-    <div>
-      <button onClick={toggleDebug}>
-        Toggle Debug Mode
-      </button>
-      <button onClick={updateApiConfig}>
-        Update API Settings
-      </button>
-    </div>
+    <ConfigManagerProvider configs={configs}>
+      {/* Votre application */}
+    </ConfigManagerProvider>
   );
 };
 ```
 
 ## 🔧 Utilisation Avancée
 
-### Variables d'environnement
-
-```bash
-# .env
-VITE_API_URL=https://api.example.com
-VITE_APP_NAME="My App"
-VITE_DEBUG=true
-NODE_ENV=development
-```
+### Accès aux variables d'environnement
 
 ```typescript
 const EnvironmentInfo = () => {
   const config = useConfig();
   
-  // Accès aux variables VITE_*
-  const apiUrl = config.getEnv('apiUrl'); // VITE_API_URL
-  const appName = config.getEnv('appName'); // VITE_APP_NAME
-  
-  // Ou via le module ENV
-  const viteApiUrl = config.get('apiUrl', { moduleName: 'ENV' });
-  
-  // Vérifier l'environnement
-  const isProd = config.isProduction();
-  const isDev = config.isDevelopment();
-  const isTest = config.isTest();
+  // Accès aux variables via le module 'env'
+  const apiUrl = config.cf('apiUrl', { moduleName: 'env' });
+  const nodeEnv = config.cf('nodeEnv', { moduleName: 'env' });
   
   return (
     <div>
       <h2>Environment Configuration</h2>
       <p>API URL: {apiUrl}</p>
-      <p>App Name: {appName}</p>
-      <p>Mode: {isProd ? 'Production' : isDev ? 'Development' : 'Test'}</p>
+      <p>Node Environment: {nodeEnv}</p>
     </div>
   );
 };
 ```
 
-### Configuration hiérarchique complexe
-
-```json
-// src/modules/complex/config.json
-{
-  "database": {
-    "connections": {
-      "primary": {
-        "host": "localhost",
-        "port": 5432,
-        "credentials": {
-          "username": "admin",
-          "password": "secret"
-        },
-        "options": {
-          "ssl": true,
-          "pool": {
-            "max": 20,
-            "min": 5,
-            "idleTimeout": 30000
-          }
-        }
-      },
-      "replica": {
-        "host": "replica.local",
-        "port": 5432
-      }
-    }
-  }
-}
-```
+### Chargement asynchrone de module
 
 ```typescript
-const DatabaseConfig = () => {
-  const config = useConfig('complex');
-  
-  // Accès aux chemins profonds
-  const primaryHost = config.get('database.connections.primary.host');
-  const poolMax = config.get('database.connections.primary.options.pool.max');
-  const sslEnabled = config.get('database.connections.primary.options.ssl');
-  
-  // Utilisation avec tableau de chemin
-  const credentials = config.get(['database', 'connections', 'primary', 'credentials']);
+const LazyModule = () => {
+  const config = useConfig();
+  const [moduleConfig, setModuleConfig] = useState(null);
+
+  useEffect(() => {
+    // Charger un module spécifique à la demande
+    config.loadModuleConfig('analytics').then(() => {
+      const analyticsConfig = config.getConfig('analytics');
+      setModuleConfig(analyticsConfig);
+    });
+  }, []);
+
+  if (!moduleConfig) return <div>Chargement du module...</div>;
   
   return (
     <div>
-      <h3>Database Configuration</h3>
-      <p>Primary Host: {primaryHost}</p>
-      <p>Max Pool Connections: {poolMax}</p>
-      <p>SSL: {sslEnabled ? 'Enabled' : 'Disabled'}</p>
-      <pre>{JSON.stringify(credentials, null, 2)}</pre>
+      <h3>Configuration Analytics</h3>
+      <pre>{JSON.stringify(moduleConfig, null, 2)}</pre>
     </div>
   );
 };
@@ -326,7 +250,7 @@ const DatabaseConfig = () => {
 
 ## 🎯 Exemples Complets
 
-### Exemple 1 : Configuration d'API avec fallback
+### Exemple 1 : Configuration d'API
 
 ```typescript
 import { useConfig } from '@arc-js/config-manager';
@@ -335,14 +259,12 @@ const ApiClient = () => {
   const config = useConfig();
   
   const getApiConfig = () => {
-    // Utiliser l'URL de l'ENV si disponible, sinon la config globale
-    const baseUrl = config.getEnv('apiUrl') || 
-                   config.get('api.baseUrl', { 
-                     defaultValue: 'http://localhost:3000' 
-                   });
+    const baseUrl = config.cf('api.baseUrl', { 
+      defaultValue: 'http://localhost:3000' 
+    });
     
-    const timeout = config.get('api.timeout', { defaultValue: 30000 });
-    const retryAttempts = config.get('api.retryAttempts', { defaultValue: 3 });
+    const timeout = config.cf('api.timeout', { defaultValue: 30000 });
+    const retryAttempts = config.cf('api.retryAttempts', { defaultValue: 3 });
     
     return { baseUrl, timeout, retryAttempts };
   };
@@ -351,13 +273,17 @@ const ApiClient = () => {
     const { baseUrl, timeout } = getApiConfig();
     
     try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      
       const response = await fetch(`\${baseUrl}/data`, {
-        timeout,
+        signal: controller.signal,
         headers: {
           'Content-Type': 'application/json'
         }
       });
       
+      clearTimeout(timeoutId);
       return await response.json();
     } catch (error) {
       console.error('API Error:', error);
@@ -378,21 +304,23 @@ const ApiClient = () => {
 ### Exemple 2 : Feature flags modulaires
 
 ```typescript
-import { useConfigValue } from '@arc-js/config-manager';
-
 const FeatureComponent = ({ featureName, moduleName }: { 
   featureName: string, 
   moduleName?: string 
 }) => {
-  const { value: isEnabled, isLoading } = useConfigValue<boolean>(
-    `features.\${featureName}`,
-    { 
-      moduleName,
-      defaultValue: false 
+  const config = useConfig(moduleName);
+  const [isEnabled, setIsEnabled] = useState(false);
+  const [isLoading, setIsLoading] = useState(true);
+
+  useEffect(() => {
+    if (config.isModuleLoaded) {
+      const enabled = config.cf(`features.\${featureName}`, { defaultValue: false });
+      setIsEnabled(enabled);
+      setIsLoading(false);
     }
-  );
-  
-  if (isLoading) return <div>Loading feature...</div>;
+  }, [config.isModuleLoaded, featureName]);
+
+  if (isLoading) return <div>Chargement de la feature...</div>;
   if (!isEnabled) return null;
   
   return (
@@ -415,69 +343,58 @@ const AppFeatures = () => {
 };
 ```
 
-### Exemple 3 : Configuration dynamique avec React Query
+## 📋 API Reference
+
+### ConfigManagerProvider
+| Prop | Type | Description |
+|------|------|-------------|
+| `configs` | `ConfigManagerConfig` | Configuration des chargeurs de configuration |
+| `children` | `React.ReactNode` | Composants enfants |
 
+### Hook useConfig
+Retourne un objet avec:
+- `cf(key: string, options?: ConfigOptions)`: Récupère une valeur de configuration
+- `getConfig(moduleName?: string)`: Récupère toute la configuration d'un module
+- `reloadConfig()`: Recharge toutes les configurations
+- `isLoading`: État de chargement global
+- `isModuleLoaded`: Indique si le module demandé est chargé
+- `loadModuleConfig(moduleName: string)`: Charge un module spécifique
+
+### Options de Configuration
 ```typescript
-import { useQuery } from '@tanstack/react-query';
-import { useConfig } from '@arc-js/config-manager';
+interface ConfigOptions {
+  moduleName?: string;      // Nom du module (défaut: 'base')
+  defaultValue?: any;       // Valeur par défaut si non trouvé
+  pathSeparator?: string;   // Séparateur de chemin (défaut: '.')
+}
+```
 
-const ConfigBasedQuery = () => {
-  const config = useConfig('admin');
+## 🛡️ Gestion des Erreurs
+
+### Fallback sécurisé
+```typescript
+const SafeComponent = () => {
+  const config = useConfig();
   
-  const { data, isLoading, error } = useQuery({
-    queryKey: ['users', 'list'],
-    queryFn: async () => {
-      const baseUrl = config.getOrThrow('api.baseUrl');
-      const pageSize = config.get('pagination.pageSize', { defaultValue: 20 });
-      
-      const response = await fetch(
-        `\${baseUrl}/users?limit=\${pageSize}`
-      );
-      
-      if (!response.ok) throw new Error('Failed to fetch');
-      return response.json();
-    },
-    // Utiliser la config pour les options de requête
-    retry: config.get('api.retryAttempts', { defaultValue: 3 }),
-    retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
-    enabled: config.get('features.dataFetching', { defaultValue: true })
+  // Utilisation sécurisée avec valeur par défaut
+  const importantValue = config.cf('important.path', {
+    defaultValue: 'valeur-par-defaut',
+    moduleName: 'admin'
   });
   
-  if (isLoading) return <div>Loading...</div>;
-  if (error) return <div>Error: {error.message}</div>;
+  // Vérifier avant utilisation
+  const adminConfig = config.getConfig('admin');
+  const hasRequiredConfig = 'requiredKey' in adminConfig;
   
-  return (
-    <div>
-      <h2>Users</h2>
-      <ul>
-        {data?.users?.map(user => (
-          <li key={user.id}>{user.name}</li>
-        ))}
-      </ul>
-    </div>
-  );
-};
-```
-
-## 🔧 Configuration Avancée
-
-### Configuration Vite
-
-```typescript
-// vite.config.ts
-import { defineConfig } from 'vite';
-import react from '@vitejs/plugin-react';
-
-export default defineConfig({
-  plugins: [react()],
-  define: {
-    // Exposer les variables d'environnement
-    'import.meta.env': process.env
+  if (!hasRequiredConfig) {
+    return <div>Configuration manquante</div>;
   }
-});
+  
+  return <div>Valeur: {importantValue}</div>;
+};
 ```
 
-### Configuration TypeScript
+## 🔧 Configuration TypeScript
 
 ```json
 {
@@ -498,97 +415,6 @@ export default defineConfig({
 }
 ```
 
-### Scripts de validation
-
-```json
-{
-  "scripts": {
-    "validate-config": "node scripts/validate-config.js",
-    "generate-config-schema": "node scripts/generate-schema.js",
-    "check-env": "node scripts/check-environment.js"
-  }
-}
-```
-
-## 📋 Table des Conventions
-
-### Chemins de configuration
-
-| Type | Format | Exemple |
-|------|--------|---------|
-| Pointé | `parent.child.grandchild` | `app.features.analytics` |
-| Tableau | `['parent', 'child', 'grandchild']` | `['api', 'baseUrl']` |
-| Mixte | Supporté | `app.features[0].name` |
-
-### Fichiers de configuration
-
-| Chemin | Portée | Priorité |
-|--------|--------|----------|
-| `src/config.json` | Globale | Base |
-| `src/modules/*/config.json` | Module | Écrase la globale |
-| `.env` / Variables | Environnement | Écrase tout |
-
-### Variables d'environnement
-
-| Variable | Conversion | Accès |
-|----------|------------|-------|
-| `VITE_API_URL` | `apiUrl` | `config.getEnv('apiUrl')` |
-| `VITE_APP_NAME` | `appName` | `config.get('appName', {moduleName: 'ENV'})` |
-| `NODE_ENV` | `nodeEnv` | `config.getEnv('NODE_ENV')` |
-
-## 🛡️ Gestion des Erreurs
-
-### Fallback et validation
-
-```typescript
-const SafeConfigAccess = () => {
-  const config = useConfig();
-  
-  try {
-    // Cette méthode lève une exception si le chemin n'existe pas
-    const requiredValue = config.getOrThrow('required.path', 'admin');
-    
-    return (
-      <div>
-        <p>Value: {requiredValue}</p>
-      </div>
-    );
-  } catch (error) {
-    return (
-      <div className="error">
-        <p>Configuration error: {(error as Error).message}</p>
-        <p>Using fallback configuration...</p>
-      </div>
-    );
-  }
-};
-```
-
-### Logs en développement
-
-```typescript
-// Le service loggue automatiquement en mode développement
-const DebugConfig = () => {
-  const config = useConfig();
-  const isDev = config.isDevelopment();
-  
-  if (isDev) {
-    // Afficher toute la configuration en dev
-    console.log('Current Configuration:', config.getAll());
-    
-    // Vérifier les chemins manquants
-    const missingPaths = ['app.name', 'api.baseUrl', 'unknown.path'];
-    missingPaths.forEach(path => {
-      if (!config.has(path)) {
-        console.warn(`Missing config path: \${path}`);
-      }
-    });
-  }
-  
-  return null;
-};
-```
-
 ## 📄 Licence
 
 MIT License - Voir le fichier [LICENSE](LICENSE) pour plus de détails.

package/config.d.ts

@@ -1,13 +1,17 @@
-declare const DEFAULT_LOCALE = "en";
-declare const SUPPORTED_LOCALES: string[];
-declare const COOKIE_NAME = "app_locale";
-type Locale = typeof SUPPORTED_LOCALES[number];
-declare const getSavedLocale: (supportedLocales?: string[]) => string;
-declare const saveLocale: (locale: string) => void;
-declare const PATH_CONFIG: {
-    SRC_DIR: string;
-};
-declare const SRC_DIR: string;
+declare const DEFAULT_CONFIG = "base";
+interface ConfigMap {
+    [key: string]: () => Promise<Record<string, any>>;
+}
+interface ModuleConfigs {
+    [moduleName: string]: () => Promise<Record<string, any>>;
+}
+interface ConfigData {
+    base: ConfigMap;
+    modules?: ModuleConfigs;
+}
+type ConfigManagerConfig = ConfigData;
+declare let configManagerConfig: ConfigManagerConfig | null;
+declare const setConfigManagerConfig: (config: ConfigManagerConfig) => void;
 
-export { COOKIE_NAME, DEFAULT_LOCALE, PATH_CONFIG, SRC_DIR, SUPPORTED_LOCALES, getSavedLocale, saveLocale };
-export type { Locale };
+export { DEFAULT_CONFIG, configManagerConfig, setConfigManagerConfig };
+export type { ConfigData, ConfigManagerConfig, ConfigMap, ModuleConfigs };