@walkeros/cli 0.4.1 → 0.5.0

package/dist/__tests__/config-loader.test.js

@@ -1,55 +1,55 @@
 /**
  * Config Loader Tests
  *
- * Tests for multi-environment configuration loading.
+ * Tests for Flow.Setup configuration loading with the new format.
  */
-import { loadBundleConfig, loadAllEnvironments, getAvailableEnvironments, } from '../config/index.js';
+import { loadBundleConfig, loadAllFlows, getAvailableFlows, } from '../config/index.js';
 describe('Config Loader', () => {
     // ========================================
-    // Single Environment Tests
+    // Single Flow (Flow.Setup with one flow)
     // ========================================
-    describe('Single Environment Config', () => {
-        test('loads single-environment config successfully', () => {
+    describe('Single Flow (Flow.Setup)', () => {
+        test('loads Flow.Setup with single flow automatically', () => {
             const config = {
-                flow: {
-                    platform: 'web',
-                    sources: {
-                        browser: {
-                            package: '@walkeros/web-source-browser',
+                version: 1,
+                flows: {
+                    default: {
+                        web: {},
+                        packages: {
+                            '@walkeros/core': { imports: ['getId'] },
                         },
-                    },
-                    destinations: {
-                        gtag: {
-                            package: '@walkeros/web-destination-gtag',
-                            config: {
-                                settings: { ga4: { measurementId: 'G-123' } },
+                        sources: {
+                            browser: {
+                                package: '@walkeros/web-source-browser',
+                            },
+                        },
+                        destinations: {
+                            gtag: {
+                                package: '@walkeros/web-destination-gtag',
+                                config: {
+                                    settings: { ga4: { measurementId: 'G-123' } },
+                                },
                             },
                         },
                     },
                 },
-                build: {
-                    packages: {},
-                    code: 'export {};',
-                    output: './dist/test.js',
-                },
             };
             const result = loadBundleConfig(config, {
                 configPath: '/test/config.json',
             });
-            expect(result.environment).toBe('default');
-            expect(result.isMultiEnvironment).toBe(false);
-            expect(result.flowConfig.platform).toBe('web');
+            expect(result.flowName).toBe('default');
+            expect(result.isMultiFlow).toBe(false);
+            expect(result.flowConfig.web).toBeDefined();
             expect(result.flowConfig.sources).toBeDefined();
         });
         test('applies platform-specific defaults for web', () => {
             const config = {
-                flow: {
-                    platform: 'web',
-                },
-                build: {
-                    packages: {},
-                    code: 'export {};',
-                    output: '',
+                version: 1,
+                flows: {
+                    default: {
+                        web: {},
+                        packages: {},
+                    },
                 },
             };
             const result = loadBundleConfig(config, {
@@ -58,18 +58,18 @@ describe('Config Loader', () => {
             expect(result.buildOptions.platform).toBe('browser');
             expect(result.buildOptions.format).toBe('iife');
             expect(result.buildOptions.target).toBe('es2020');
+            expect(result.buildOptions.minify).toBe(true);
             // Output path is resolved relative to config file directory
             expect(result.buildOptions.output).toBe('/test/dist/walker.js');
         });
         test('applies platform-specific defaults for server', () => {
             const config = {
-                flow: {
-                    platform: 'server',
-                },
-                build: {
-                    packages: {},
-                    code: 'export {};',
-                    output: '',
+                version: 1,
+                flows: {
+                    default: {
+                        server: {},
+                        packages: {},
+                    },
                 },
             };
             const result = loadBundleConfig(config, {
@@ -78,266 +78,265 @@ describe('Config Loader', () => {
             expect(result.buildOptions.platform).toBe('node');
             expect(result.buildOptions.format).toBe('esm');
             expect(result.buildOptions.target).toBe('node20');
+            expect(result.buildOptions.minify).toBe(true);
             // Output path is resolved relative to config file directory
-            expect(result.buildOptions.output).toBe('/test/dist/bundle.js');
+            expect(result.buildOptions.output).toBe('/test/dist/bundle.mjs');
         });
-        test('merges custom build options with defaults', () => {
+        test('extracts packages from flowConfig', () => {
             const config = {
-                flow: {
-                    platform: 'web',
-                },
-                build: {
-                    packages: {},
-                    code: 'export {};',
-                    output: '',
-                    minify: true,
-                    format: 'esm',
+                version: 1,
+                flows: {
+                    default: {
+                        web: {},
+                        packages: {
+                            '@walkeros/core': { imports: ['getId', 'clone'] },
+                            '@walkeros/destination-demo': { imports: ['destinationDemo'] },
+                        },
+                    },
                 },
             };
             const result = loadBundleConfig(config, {
                 configPath: '/test/config.json',
             });
-            expect(result.buildOptions.minify).toBe(true);
-            expect(result.buildOptions.format).toBe('esm'); // Custom overrides default
-            expect(result.buildOptions.target).toBe('es2020'); // Default preserved
+            expect(result.buildOptions.packages).toEqual({
+                '@walkeros/core': { imports: ['getId', 'clone'] },
+                '@walkeros/destination-demo': { imports: ['destinationDemo'] },
+            });
         });
-        test('auto-selects templates based on platform', () => {
+        test('respects build overrides from CLI', () => {
             const config = {
-                flow: {
-                    platform: 'web',
-                },
-                build: {
-                    packages: {},
-                    code: 'export {};',
-                    output: '',
+                version: 1,
+                flows: {
+                    default: {
+                        web: {},
+                        packages: {},
+                    },
                 },
             };
             const result = loadBundleConfig(config, {
                 configPath: '/test/config.json',
+                buildOverrides: {
+                    minify: false,
+                    output: '/custom/output.js',
+                },
             });
-            // Should auto-select web.hbs for web platform
-            expect(result.buildOptions.template).toBe('web.hbs');
+            expect(result.buildOptions.minify).toBe(false);
+            expect(result.buildOptions.output).toBe('/custom/output.js');
         });
     });
     // ========================================
-    // Multi-Environment Tests
+    // Multi-Flow Tests
     // ========================================
-    describe('Multi-Environment Config', () => {
-        const multiEnvConfig = {
+    describe('Multi-Flow Config', () => {
+        const multiFlowConfig = {
             version: 1,
-            environments: {
+            flows: {
                 web_prod: {
-                    flow: {
-                        platform: 'web',
-                        sources: {
-                            browser: {
-                                package: '@walkeros/web-source-browser',
-                            },
-                        },
-                        destinations: {
-                            gtag: {
-                                package: '@walkeros/web-destination-gtag',
-                                config: { settings: { ga4: { measurementId: 'G-PROD' } } },
-                            },
+                    web: {},
+                    packages: {},
+                    sources: {
+                        browser: {
+                            package: '@walkeros/web-source-browser',
                         },
                     },
-                    build: {
-                        packages: {},
-                        code: 'export {};',
-                        output: './dist/prod.js',
+                    destinations: {
+                        gtag: {
+                            package: '@walkeros/web-destination-gtag',
+                            config: { settings: { ga4: { measurementId: 'G-PROD' } } },
+                        },
                     },
                 },
                 web_stage: {
-                    flow: {
-                        platform: 'web',
-                        sources: {
-                            browser: {
-                                package: '@walkeros/web-source-browser',
-                            },
-                        },
-                        destinations: {
-                            gtag: {
-                                package: '@walkeros/web-destination-gtag',
-                                config: { settings: { ga4: { measurementId: 'G-STAGE' } } },
-                            },
+                    web: {},
+                    packages: {},
+                    sources: {
+                        browser: {
+                            package: '@walkeros/web-source-browser',
                         },
                     },
-                    build: {
-                        packages: {},
-                        code: 'export {};',
-                        output: './dist/stage.js',
+                    destinations: {
+                        gtag: {
+                            package: '@walkeros/web-destination-gtag',
+                            config: { settings: { ga4: { measurementId: 'G-STAGE' } } },
+                        },
                     },
                 },
                 server_prod: {
-                    flow: {
-                        platform: 'server',
-                        destinations: {
-                            api: {
-                                package: '@walkeros/server-destination-api',
-                            },
+                    server: {},
+                    packages: {},
+                    destinations: {
+                        api: {
+                            package: '@walkeros/server-destination-api',
                         },
                     },
-                    build: {
-                        packages: {},
-                        code: 'export {};',
-                        output: './dist/server.js',
-                    },
                 },
             },
         };
-        test('loads specific environment from multi-environment config', () => {
-            const result = loadBundleConfig(multiEnvConfig, {
+        test('loads specific flow from multi-flow config', () => {
+            const result = loadBundleConfig(multiFlowConfig, {
                 configPath: '/test/config.json',
-                environment: 'web_prod',
+                flowName: 'web_prod',
             });
-            expect(result.environment).toBe('web_prod');
-            expect(result.isMultiEnvironment).toBe(true);
-            expect(result.availableEnvironments).toEqual([
+            expect(result.flowName).toBe('web_prod');
+            expect(result.isMultiFlow).toBe(true);
+            expect(result.availableFlows).toEqual([
                 'web_prod',
                 'web_stage',
                 'server_prod',
             ]);
-            expect(result.flowConfig.platform).toBe('web');
+            expect(result.flowConfig.web).toBeDefined();
         });
-        test('throws error if environment not specified for multi-env config', () => {
-            expect(() => loadBundleConfig(multiEnvConfig, {
+        test('throws error if flow not specified for multi-flow config', () => {
+            expect(() => loadBundleConfig(multiFlowConfig, {
                 configPath: '/test/config.json',
-            })).toThrow('Please specify an environment using --env flag');
+            })).toThrow('Please specify a flow using --flow flag');
         });
-        test('throws error if specified environment not found', () => {
-            expect(() => loadBundleConfig(multiEnvConfig, {
+        test('throws error if specified flow not found', () => {
+            expect(() => loadBundleConfig(multiFlowConfig, {
                 configPath: '/test/config.json',
-                environment: 'nonexistent',
-            })).toThrow('Environment "nonexistent" not found');
+                flowName: 'nonexistent',
+            })).toThrow('Flow "nonexistent" not found');
         });
-        test('loads all environments', () => {
-            const results = loadAllEnvironments(multiEnvConfig, {
+        test('loads all flows', () => {
+            const results = loadAllFlows(multiFlowConfig, {
                 configPath: '/test/config.json',
             });
             expect(results).toHaveLength(3);
-            expect(results.map((r) => r.environment)).toEqual([
+            expect(results.map((r) => r.flowName)).toEqual([
                 'web_prod',
                 'web_stage',
                 'server_prod',
             ]);
-            expect(results[0].flowConfig.platform).toBe('web');
-            expect(results[2].flowConfig.platform).toBe('server');
-        });
-        test('throws error if --all used with single-environment config', () => {
-            const singleConfig = {
-                flow: { platform: 'web' },
-                build: { packages: {}, code: 'export {};', output: '' },
-            };
-            expect(() => loadAllEnvironments(singleConfig, {
-                configPath: '/test/config.json',
-            })).toThrow('--all flag requires a multi-environment configuration');
-        });
-        test('gets available environments from multi-env config', () => {
-            const environments = getAvailableEnvironments(multiEnvConfig);
-            expect(environments).toEqual(['web_prod', 'web_stage', 'server_prod']);
+            expect(results[0].flowConfig.web).toBeDefined();
+            expect(results[2].flowConfig.server).toBeDefined();
         });
-        test('returns empty array for single-env config', () => {
-            const singleConfig = {
-                flow: { platform: 'web' },
-                build: { packages: {}, code: 'export {};', output: '' },
-            };
-            const environments = getAvailableEnvironments(singleConfig);
-            expect(environments).toEqual([]);
+        test('gets available flows from multi-flow config', () => {
+            const flows = getAvailableFlows(multiFlowConfig);
+            expect(flows).toEqual(['web_prod', 'web_stage', 'server_prod']);
         });
     });
     // ========================================
     // Error Handling Tests
     // ========================================
     describe('Error Handling', () => {
-        test('throws detailed error for invalid config format', () => {
+        test('throws error for invalid config format (missing version)', () => {
             const invalidConfig = {
-                flow: {
-                    platform: 'invalid',
+                flows: {
+                    default: { web: {} },
                 },
-                build: { packages: {}, code: 'export {};', output: '' },
             };
             expect(() => loadBundleConfig(invalidConfig, {
                 configPath: '/test/config.json',
-            })).toThrow('Invalid platform "invalid". Must be "web" or "server".');
+            })).toThrow(/Invalid configuration[\s\S]*version/);
         });
-        test('throws error for missing required fields', () => {
-            const invalidConfig = {};
+        test('throws error for invalid config format (wrong version)', () => {
+            const invalidConfig = {
+                version: 2,
+                flows: {
+                    default: { web: {} },
+                },
+            };
             expect(() => loadBundleConfig(invalidConfig, {
                 configPath: '/test/config.json',
-            })).toThrow();
+            })).toThrow(/Invalid configuration[\s\S]*version/);
         });
-        test('throws error for invalid version in multi-env config', () => {
+        test('throws error for invalid config format (missing flows)', () => {
             const invalidConfig = {
-                version: 2,
-                environments: {
-                    prod: {
-                        flow: { platform: 'web' },
-                        build: { packages: {}, code: 'export {};', output: '' },
+                version: 1,
+            };
+            expect(() => loadBundleConfig(invalidConfig, {
+                configPath: '/test/config.json',
+            })).toThrow(/Invalid configuration[\s\S]*flows/);
+        });
+        test('throws error for empty flows', () => {
+            const invalidConfig = {
+                version: 1,
+                flows: {},
+            };
+            expect(() => loadBundleConfig(invalidConfig, {
+                configPath: '/test/config.json',
+            })).toThrow(/at least one flow/i);
+        });
+        test('throws error for flow without web/server key', () => {
+            const invalidConfig = {
+                version: 1,
+                flows: {
+                    default: {
+                        packages: {},
                     },
                 },
             };
             expect(() => loadBundleConfig(invalidConfig, {
                 configPath: '/test/config.json',
-                environment: 'prod',
-            })).toThrow();
+            })).toThrow(/web.*or.*server|Exactly one of/i);
+        });
+        test('returns empty array for non-Flow.Setup config', () => {
+            const oldFormatConfig = {
+                flow: { platform: 'web' },
+                build: { packages: {} },
+            };
+            const flows = getAvailableFlows(oldFormatConfig);
+            expect(flows).toEqual([]);
         });
     });
     // ========================================
     // Logger Integration Tests
     // ========================================
     describe('Logger Integration', () => {
-        test('logs info message for multi-environment config', () => {
+        test('logs info message for multi-flow config', () => {
             const logger = {
                 info: jest.fn(),
                 warn: jest.fn(),
             };
             const config = {
                 version: 1,
-                environments: {
+                flows: {
                     prod: {
-                        flow: { platform: 'web' },
-                        build: { packages: {}, code: 'export {};', output: '' },
+                        web: {},
+                        packages: {},
+                    },
+                    stage: {
+                        web: {},
+                        packages: {},
                     },
                 },
             };
             loadBundleConfig(config, {
                 configPath: '/test/config.json',
-                environment: 'prod',
+                flowName: 'prod',
                 logger,
             });
-            expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('Using environment: prod'));
+            expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('Using flow: prod'));
         });
-        test('logs warning for ignored --env flag on single-env config', () => {
+        test('does not log for single-flow config', () => {
             const logger = {
                 info: jest.fn(),
                 warn: jest.fn(),
             };
             const config = {
-                flow: {
-                    platform: 'web',
-                },
-                build: {
-                    packages: {},
-                    code: 'export {};',
-                    output: '',
+                version: 1,
+                flows: {
+                    default: {
+                        web: {},
+                        packages: {},
+                    },
                 },
             };
             loadBundleConfig(config, {
                 configPath: '/test/config.json',
-                environment: 'ignored',
                 logger,
             });
-            expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('configuration is single-environment'));
+            // Should not log flow selection for single-flow
+            expect(logger.info).not.toHaveBeenCalled();
         });
     });
     // ========================================
     // Real-World Scenario Tests
     // ========================================
     describe('Real-World Scenarios', () => {
-        test('loads complex multi-environment setup', () => {
+        test('loads complex multi-flow setup', () => {
             const complexConfig = {
                 version: 1,
-                $schema: 'https://walkeros.io/schema/flow/v1.json',
                 variables: {
                     CURRENCY: 'USD',
                 },
@@ -346,51 +345,69 @@ describe('Config Loader', () => {
                         page: { view: { name: 'page_view' } },
                     },
                 },
-                environments: {
+                flows: {
                     web_production: {
-                        flow: {
-                            platform: 'web',
-                            sources: {
-                                browser: {
-                                    package: '@walkeros/web-source-browser@2.0.0',
-                                    config: {
-                                        settings: { pageview: true },
-                                    },
-                                    primary: true,
-                                },
+                        web: {},
+                        packages: {
+                            '@walkeros/collector': { imports: ['startFlow'] },
+                            '@walkeros/web-source-browser': { imports: ['sourceBrowser'] },
+                            '@walkeros/web-destination-gtag': {
+                                imports: ['destinationGtag'],
                             },
-                            destinations: {
-                                gtag: {
-                                    package: '@walkeros/web-destination-gtag@2.0.0',
-                                    config: {
-                                        settings: { ga4: { measurementId: 'G-PROD' } },
-                                    },
+                        },
+                        sources: {
+                            browser: {
+                                package: '@walkeros/web-source-browser@2.0.0',
+                                config: {
+                                    settings: { pageview: true },
                                 },
+                                primary: true,
                             },
-                            collector: {
-                                run: true,
-                                tagging: 1,
+                        },
+                        destinations: {
+                            gtag: {
+                                package: '@walkeros/web-destination-gtag@2.0.0',
+                                config: {
+                                    settings: { ga4: { measurementId: 'G-PROD' } },
+                                },
                             },
                         },
-                        build: {
-                            packages: {},
-                            code: 'export {};',
-                            minify: true,
-                            sourcemap: false,
-                            output: './dist/walker.min.js',
+                        collector: {
+                            run: true,
+                            tagging: 1,
                         },
                     },
                 },
             };
             const result = loadBundleConfig(complexConfig, {
                 configPath: '/test/config.json',
-                environment: 'web_production',
+                flowName: 'web_production',
             });
-            expect(result.flowConfig.platform).toBe('web');
+            expect(result.flowConfig.web).toBeDefined();
             expect(result.flowConfig.sources?.browser?.package).toBe('@walkeros/web-source-browser@2.0.0');
             expect(result.buildOptions.minify).toBe(true);
-            // Output path is resolved relative to config file directory
-            expect(result.buildOptions.output).toBe('/test/dist/walker.min.js');
+            // Output uses convention default
+            expect(result.buildOptions.output).toBe('/test/dist/walker.js');
+        });
+        test('extracts windowCollector and windowElb from web config', () => {
+            const config = {
+                version: 1,
+                flows: {
+                    default: {
+                        web: {
+                            windowCollector: 'myCollector',
+                            windowElb: 'myElb',
+                        },
+                        packages: {},
+                    },
+                },
+            };
+            const result = loadBundleConfig(config, {
+                configPath: '/test/config.json',
+            });
+            // Web config values should be in flowConfig
+            expect(result.flowConfig.web.windowCollector).toBe('myCollector');
+            expect(result.flowConfig.web.windowElb).toBe('myElb');
         });
     });
 });