@contractkit/plugin-bruno 1.0.0 → 1.1.0

package/src/codegen-bruno.ts

@@ -55,6 +55,17 @@ export interface OpenCollectionOptions {
      * benefit from full coverage. Set to `false` to omit internal ops.
      */
     includeInternal?: boolean;
+    /**
+     * Map of environment name → variables. Each entry produces a
+     * `environments/<name>.yml` file with the variables in declaration order.
+     * Values are coerced to strings.
+     *
+     * When omitted, a default `environments/local.yml` is emitted with
+     * `baseUrl=http://localhost:3000` plus any auth env-var placeholders the
+     * default scheme requires. When provided, the default is replaced entirely
+     * — auth vars are not auto-injected, so include them explicitly if needed.
+     */
+    environments?: Record<string, Record<string, unknown>>;
 }
 
 /**
@@ -72,7 +83,9 @@ export function generateOpenCollection(roots: OpRootNode[], options: OpenCollect
     const includeInternal = options.includeInternal ?? true;
 
     files.push({ relativePath: 'opencollection.yml', content: generateCollectionRoot(options.collectionName, defaultScheme) });
-    files.push({ relativePath: 'environments/local.yml', content: generateEnvFile(defaultScheme) });
+    for (const envFile of generateEnvFiles(options.environments, defaultScheme)) {
+        files.push(envFile);
+    }
     // Manifest is appended at the end so it lists every generated path including itself.
 
     for (let rootIdx = 0; rootIdx < roots.length; rootIdx++) {
@@ -183,18 +196,38 @@ function generateCollectionRoot(name: string, scheme?: BrunoSecurityScheme): str
     return lines.join('\n');
 }
 
-function generateEnvFile(scheme?: BrunoSecurityScheme): string {
-    const lines = [`name: Local`, `variables:`, `  - name: baseUrl`, `    value: "http://localhost:3000"`];
+function generateEnvFiles(
+    environments: Record<string, Record<string, unknown>> | undefined,
+    scheme: BrunoSecurityScheme | undefined,
+): OpenCollectionFile[] {
+    if (environments && Object.keys(environments).length > 0) {
+        return Object.entries(environments).map(([name, variables]) => ({
+            relativePath: `environments/${name}.yml`,
+            content: renderEnvFile(displayNameFor(name), variables),
+        }));
+    }
+    const defaultVars: Record<string, string> = { baseUrl: 'http://localhost:3000' };
     if (scheme) {
-        for (const varName of authEnvVarNames(scheme)) {
-            lines.push(`  - name: ${varName}`);
-            lines.push(`    value: ""`);
-        }
+        for (const varName of authEnvVarNames(scheme)) defaultVars[varName] = '';
+    }
+    return [{ relativePath: 'environments/local.yml', content: renderEnvFile('Local', defaultVars) }];
+}
+
+function renderEnvFile(name: string, variables: Record<string, unknown>): string {
+    const lines = [`name: ${name}`, `variables:`];
+    for (const [key, value] of Object.entries(variables)) {
+        const escaped = String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        lines.push(`  - name: ${key}`);
+        lines.push(`    value: "${escaped}"`);
     }
     lines.push(``);
     return lines.join('\n');
 }
 
+function displayNameFor(envKey: string): string {
+    return envKey.charAt(0).toUpperCase() + envKey.slice(1);
+}
+
 function generateFolderFile(name: string, seq: number): string {
     return [`info:`, `  name: ${yamlString(name)}`, `  type: folder`, `  seq: ${seq}`, ``].join('\n');
 }

package/src/index.ts

@@ -21,6 +21,14 @@ export interface BrunoPluginConfig {
      * benefit from full coverage. Set to `false` to omit internal ops.
      */
     includeInternal?: boolean;
+    /**
+     * Map of environment name → variables. Each entry produces a
+     * `environments/<name>.yml` file. When omitted, a default `local.yml` is
+     * emitted with `baseUrl=http://localhost:3000` and any auth env-var
+     * placeholders. When provided, the default is replaced entirely; include
+     * auth variables (e.g. `token`) explicitly if you need them.
+     */
+    environments?: Record<string, Record<string, unknown>>;
 }
 
 /** Full plugin options shape read from `ctx.options` — extends {@link BrunoPluginConfig} with the `auth` block. */
@@ -47,6 +55,7 @@ const plugin: ContractKitPlugin = {
             auth,
             randomExamples: config.randomExamples ?? true,
             includeInternal: config.includeInternal,
+            environments: config.environments,
         });
         for (const { relativePath, content } of files) {
             ctx.emitFile(resolve(outDir, relativePath), content);
@@ -88,6 +97,8 @@ export function createBrunoPlugin(
                 contractRoots,
                 auth,
                 randomExamples: config.randomExamples ?? true,
+                includeInternal: config.includeInternal,
+                environments: config.environments,
             });
             for (const { relativePath, content } of files) {
                 ctx.emitFile(resolve(outDir, relativePath), content);

package/tests/codegen-bruno.test.ts

@@ -671,6 +671,61 @@ describe('generateOpenCollection', () => {
         expect(env!.content).toContain('- name: token');
     });
 
+    describe('environments config', () => {
+        const root = opRoot([opRoute('/users', [opOperation('get')])], 'users.op');
+
+        it('emits one file per entry, replacing the default local.yml', () => {
+            const files = generateOpenCollection([root], {
+                collectionName: 'API',
+                environments: {
+                    local: { baseUrl: 'http://localhost:3000', token: '' },
+                    staging: { baseUrl: 'https://staging.example.com', token: 'secret' },
+                },
+            });
+            const local = files.find(f => f.relativePath === 'environments/local.yml');
+            const staging = files.find(f => f.relativePath === 'environments/staging.yml');
+            expect(local).toBeDefined();
+            expect(staging).toBeDefined();
+            expect(local!.content).toContain('name: Local');
+            expect(local!.content).toContain('- name: baseUrl');
+            expect(local!.content).toContain('value: "http://localhost:3000"');
+            expect(local!.content).toContain('- name: token');
+            expect(staging!.content).toContain('name: Staging');
+            expect(staging!.content).toContain('value: "https://staging.example.com"');
+            expect(staging!.content).toContain('value: "secret"');
+        });
+
+        it('does not auto-inject auth env vars when environments is provided', () => {
+            const files = generateOpenCollection([root], {
+                collectionName: 'API',
+                auth: bearerAuth,
+                environments: {
+                    local: { baseUrl: 'http://localhost:3000' },
+                },
+            });
+            const local = files.find(f => f.relativePath === 'environments/local.yml');
+            expect(local!.content).not.toContain('- name: token');
+        });
+
+        it('falls back to the default local.yml when environments is empty', () => {
+            const files = generateOpenCollection([root], { collectionName: 'API', environments: {} });
+            const local = files.find(f => f.relativePath === 'environments/local.yml');
+            expect(local).toBeDefined();
+            expect(local!.content).toContain('name: Local');
+            expect(local!.content).toContain('value: "http://localhost:3000"');
+        });
+
+        it('coerces non-string values to strings', () => {
+            const files = generateOpenCollection([root], {
+                collectionName: 'API',
+                environments: { local: { port: 3000, debug: true } as unknown as Record<string, unknown> },
+            });
+            const local = files.find(f => f.relativePath === 'environments/local.yml');
+            expect(local!.content).toContain('value: "3000"');
+            expect(local!.content).toContain('value: "true"');
+        });
+    });
+
     it('does not add request or auth to opencollection.yml when no security config', () => {
         const root = opRoot([opRoute('/users', [opOperation('get')])], 'users.op');
         const files = generateOpenCollection([root], { collectionName: 'API' });