@usebruno/filestore 0.10.0 → 0.12.0

package/src/formats/yml/items/stringifyHttpRequest.ts

@@ -8,6 +8,7 @@ import type { Assertion } from '@opencollection/types/common/assertions';
 import type { Action } from '@opencollection/types/common/actions';
 import type { HttpRequestParam, HttpRequestBody } from '@opencollection/types/requests/http';
 import { stringifyYml } from '../utils';
+import { toOpenCollectionApp, OpenCollectionApp } from '../common/app';
 import { toOpenCollectionAuth } from '../common/auth';
 import { toOpenCollectionHttpHeaders, toOpenCollectionResponseHeaders } from '../common/headers';
 import { toOpenCollectionParams } from '../common/params';
@@ -17,6 +18,7 @@ import { toOpenCollectionActions } from '../common/actions';
 import { toOpenCollectionScripts } from '../common/scripts';
 import { toOpenCollectionAssertions } from '../common/assertions';
 import { isNumber, isNonEmptyString } from '../../../utils';
+import { resolveTimeoutSetting } from '@usebruno/common/utils';
 
 const stringifyHttpRequest = (item: BrunoItem): string => {
   try {
@@ -34,6 +36,9 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
     if (item.tags?.length) {
       info.tags = item.tags;
     }
+    if (isNonEmptyString(item.description)) {
+      info.description = item.description;
+    }
     ocRequest.info = info;
 
     // http block
@@ -116,12 +121,7 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
       settings.encodeUrl = true;
     }
 
-    const timeout = httpSettings?.timeout;
-    if (isNumber(timeout)) {
-      settings.timeout = timeout;
-    } else {
-      settings.timeout = 0;
-    }
+    settings.timeout = resolveTimeoutSetting(httpSettings?.timeout);
 
     if (httpSettings?.followRedirects === true) {
       settings.followRedirects = true;
@@ -138,6 +138,8 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
       settings.maxRedirects = 5;
     }
 
+    settings.forwardAuthorizationHeader = httpSettings?.forwardAuthorizationHeader ?? true;
+
     ocRequest.settings = settings;
 
     // examples
@@ -212,6 +214,12 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
       ocRequest.docs = brunoRequest.docs;
     }
 
+    // app
+    const app: OpenCollectionApp | undefined = toOpenCollectionApp(item.app);
+    if (app) {
+      (ocRequest as any).app = app;
+    }
+
     return stringifyYml(ocRequest);
   } catch (error) {
     console.error('Error stringifying HTTP request:', error);

package/src/formats/yml/items/stringifyWebsocketRequest.ts

@@ -1,6 +1,6 @@
 import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
 import type { WebSocketRequest as BrunoWebSocketRequest } from '@usebruno/schema-types/requests/websocket';
-import type { WebSocketRequest, WebSocketMessage, WebSocketRequestInfo, WebSocketRequestDetails, WebSocketRequestRuntime } from '@opencollection/types/requests/websocket';
+import type { WebSocketRequest, WebSocketRequestInfo, WebSocketRequestDetails, WebSocketRequestRuntime, WebSocketMessage, WebSocketMessageVariant } from '@opencollection/types/requests/websocket';
 import type { Auth } from '@opencollection/types/common/auth';
 import type { Scripts } from '@opencollection/types/common/scripts';
 import type { Variable } from '@opencollection/types/common/variables';
@@ -28,6 +28,9 @@ const stringifyWebsocketRequest = (item: BrunoItem): string => {
     if (item.tags?.length) {
       info.tags = item.tags;
     }
+    if (isNonEmptyString(item.description)) {
+      info.description = item.description;
+    }
     ocRequest.info = info;
 
     // websocket block
@@ -41,21 +44,31 @@ const stringifyWebsocketRequest = (item: BrunoItem): string => {
       websocket.headers = headers;
     }
 
-    // message
+    // message: single message without a custom name uses flat WebSocketMessage (backward compatible),
+    // otherwise uses WebSocketMessageVariant[] to preserve names
     if (brunoRequest.body?.mode === 'ws' && brunoRequest.body.ws?.length) {
       const messages = brunoRequest.body.ws;
+      const hasCustomName = messages.length === 1 && messages[0].name && messages[0].name.trim().length > 0;
+
+      const hasContent = messages.length === 1 && (messages[0].content || '').trim().length > 0;
 
-      // todo: bruno app supports only one message for now
-      // update this when bruno app supports multiple messages
-      if (messages.length) {
+      if (messages.length === 1 && !hasCustomName && hasContent) {
         const msg = messages[0];
         const message: WebSocketMessage = {
-          type: (msg.type as 'text' | 'json' | 'xml' | 'binary') || 'text',
+          type: (msg.type as WebSocketMessage['type']) || 'text',
           data: msg.content || ''
         };
-        if (message.data.trim().length) {
-          websocket.message = message;
-        }
+        websocket.message = message;
+      } else {
+        const variants: WebSocketMessageVariant[] = messages.map((msg, index) => ({
+          title: msg.name || `message ${index + 1}`,
+          selected: msg.selected || false,
+          message: {
+            type: (msg.type as WebSocketMessage['type']) || 'text',
+            data: msg.content || ''
+          }
+        }));
+        websocket.message = variants;
       }
     }
 

package/src/formats/yml/mockServerTypes.ts

@@ -0,0 +1,95 @@
+import type { HttpRequestHeader, HttpResponseHeader, HttpRequestParam, HttpRequestBody } from '@opencollection/types/requests/http';
+
+export interface MockRuleCondition {
+  target?: string;
+  key?: string;
+  operator?: string;
+  value?: string;
+}
+
+export interface MockRouteRules {
+  operator?: 'AND' | 'OR';
+  conditions?: MockRuleCondition[];
+}
+
+export interface MockRouteEntry {
+  name?: string;
+  description?: string;
+  request?: {
+    method?: string;
+    url?: string;
+    headers?: HttpRequestHeader[];
+    params?: HttpRequestParam[];
+    body?: HttpRequestBody;
+  };
+  response?: {
+    status?: number;
+    statusText?: string;
+    headers?: HttpResponseHeader[];
+    body?: {
+      type?: string;
+      data?: string;
+    };
+  };
+  rules?: MockRouteRules;
+  copiedFrom?: {
+    example?: string | null;
+    requestPath?: string | null;
+  };
+}
+
+export interface MockServerFile {
+  info?: {
+    name?: string;
+    type?: 'mock';
+  };
+  mock?: {
+    port?: number;
+    delay?: number;
+    source?: {
+      type?: 'collection' | 'spec';
+      path?: string;
+    };
+  };
+  routes?: MockRouteEntry[];
+}
+
+export interface BrunoMockRoute {
+  name: string;
+  description: string;
+  request: {
+    url: string;
+    method: string;
+    headers: any[];
+    params: any[];
+    body: any;
+  };
+  response: {
+    status: number;
+    statusText: string;
+    headers: any[];
+    body: {
+      type: string;
+      content: string;
+    };
+  };
+  rules: {
+    operator: 'AND' | 'OR';
+    conditions: Array<{ target: string; key: string; operator: string; value: string }>;
+  };
+  copiedFrom?: {
+    exampleName: string | null;
+    requestPathname: string | null;
+  };
+}
+
+export interface BrunoMockServer {
+  name: string;
+  port: number | null;
+  delay: number;
+  source: {
+    type: 'collection' | 'spec';
+    path: string;
+  } | null;
+  routes: BrunoMockRoute[];
+}

package/src/formats/yml/parseCollection.spec.ts

@@ -0,0 +1,193 @@
+import parseCollection from './parseCollection';
+
+// Typed `request.variables` propagate through parseCollection into the
+// collectionRoot's vars.req with their dataType + coerced value.
+
+describe('parseCollection — typed request.variables', () => {
+  it('coerces typed values, preserves raw value on un-coercible input, and treats explicit string as the implicit default', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+
+request:
+  variables:
+    - name: count
+      value:
+        type: number
+        data: "42"
+    - name: enabled
+      value:
+        type: boolean
+        data: "true"
+    - name: config
+      value:
+        type: object
+        data: '{"a":1}'
+    - name: greeting
+      value:
+        type: string
+        data: hi
+    - name: plain
+      value: hello
+    - name: cfg
+      value:
+        type: object
+        data: 'not-json'
+`;
+
+    const { collectionRoot } = parseCollection(yml);
+    const reqVars = collectionRoot.request!.vars!.req!;
+
+    expect(reqVars).toHaveLength(6);
+    expect(reqVars[0]).toMatchObject({ name: 'count', value: 42, dataType: 'number' });
+    expect(reqVars[1]).toMatchObject({ name: 'enabled', value: true, dataType: 'boolean' });
+    expect(reqVars[2]).toMatchObject({ name: 'config', value: { a: 1 }, dataType: 'object' });
+    // Explicit `type: string` is the implicit default — no dataType materialized.
+    expect(reqVars[3]).toMatchObject({ name: 'greeting', value: 'hi' });
+    expect(reqVars[3].dataType).toBeUndefined();
+    expect(reqVars[4]).toMatchObject({ name: 'plain', value: 'hello' });
+    expect(reqVars[4].dataType).toBeUndefined();
+    // Un-coercible: raw value preserved for the UI mismatch warning.
+    expect(reqVars[5]).toMatchObject({ name: 'cfg', value: 'not-json', dataType: 'object' });
+  });
+});
+
+describe('parseCollection — script execution flow', () => {
+  it('reads flow: sequential from the bruno extension', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+extensions:
+  bruno:
+    scripts:
+      flow: sequential
+`;
+    const { brunoConfig } = parseCollection(yml);
+    expect(brunoConfig.scripts?.flow).toBe('sequential');
+  });
+
+  it('reads flow: sandwich from the bruno extension', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+extensions:
+  bruno:
+    scripts:
+      flow: sandwich
+`;
+    const { brunoConfig } = parseCollection(yml);
+    expect(brunoConfig.scripts?.flow).toBe('sandwich');
+  });
+
+  it('ignores an unrecognized flow value', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+extensions:
+  bruno:
+    scripts:
+      flow: parallel
+`;
+    const { brunoConfig } = parseCollection(yml);
+    expect(brunoConfig.scripts?.flow).toBeUndefined();
+  });
+
+  it('has no scripts.flow when the file does not set one', () => {
+    const { brunoConfig } = parseCollection('opencollection: "1.0.0"\ninfo:\n  name: c\n');
+    expect(brunoConfig.scripts?.flow).toBeUndefined();
+  });
+});
+
+describe('parseCollection — client certificates', () => {
+  it('maps pem and pkcs12 certs to Bruno cert/pfx shapes', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+config:
+  clientCertificates:
+    - domain: localhost
+      type: pem
+      certificateFilePath: ./certs/client-cert.pem
+      privateKeyFilePath: ./certs/client-key.pem
+      passphrase: secret
+    - domain: example.com
+      type: pkcs12
+      pkcs12FilePath: ./certs/client.pfx
+`;
+    const { brunoConfig } = parseCollection(yml);
+
+    expect(brunoConfig.clientCertificates.certs).toEqual([
+      {
+        domain: 'localhost',
+        type: 'cert',
+        certFilePath: './certs/client-cert.pem',
+        keyFilePath: './certs/client-key.pem',
+        passphrase: 'secret'
+      },
+      {
+        domain: 'example.com',
+        type: 'pfx',
+        pfxFilePath: './certs/client.pfx',
+        passphrase: ''
+      }
+    ]);
+  });
+
+  it('drops certs with an unrecognized type', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+config:
+  clientCertificates:
+    - domain: localhost
+      type: bogus
+      certificateFilePath: ./certs/client-cert.pem
+`;
+    const { brunoConfig } = parseCollection(yml);
+
+    expect(brunoConfig.clientCertificates.certs).toEqual([]);
+  });
+
+  it('reads a per-cert disabled flag when set to true, otherwise leaves it off', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+config:
+  clientCertificates:
+    - domain: localhost
+      type: pem
+      certificateFilePath: ./certs/client-cert.pem
+      privateKeyFilePath: ./certs/client-key.pem
+      disabled: true
+    - domain: example.com
+      type: pkcs12
+      pkcs12FilePath: ./certs/client.pfx
+      disabled: true
+    - domain: other.com
+      type: pkcs12
+      pkcs12FilePath: ./certs/other.pfx
+`;
+    const { brunoConfig } = parseCollection(yml);
+
+    expect(brunoConfig.clientCertificates.certs[0].disabled).toBe(true);
+    expect(brunoConfig.clientCertificates.certs[1].disabled).toBe(true);
+    expect(brunoConfig.clientCertificates.certs[2]).not.toHaveProperty('disabled');
+  });
+});
+
+describe('parseCollection — reading the collection version', () => {
+  it('reads the version from the file as text', () => {
+    const { brunoConfig } = parseCollection('opencollection: "1.0.0"\ninfo:\n  name: c\n  version: v1.0.0\n');
+    expect(brunoConfig.version).toBe('v1.0.0');
+  });
+
+  it('turns a number version into text (2 becomes "2")', () => {
+    const { brunoConfig } = parseCollection('opencollection: "1.0.0"\ninfo:\n  name: c\n  version: 2\n');
+    expect(brunoConfig.version).toBe('2');
+  });
+
+  it('has no version when the file does not have one', () => {
+    const { brunoConfig } = parseCollection('opencollection: "1.0.0"\ninfo:\n  name: c\n');
+    expect(brunoConfig.version).toBeUndefined();
+  });
+});

package/src/formats/yml/parseCollection.ts

@@ -7,6 +7,7 @@ import { toBrunoVariables } from './common/variables';
 import { toBrunoPostResponseVariables } from './common/actions';
 import { toBrunoScripts } from './common/scripts';
 import { ensureString } from '../../utils';
+import type { BrunoPresetsExtension } from '../../types';
 
 interface ParsedCollection {
   collectionRoot: FolderRoot;
@@ -25,6 +26,10 @@ const parseCollection = (ymlString: string): ParsedCollection => {
       ignore: []
     };
 
+    if (oc.info?.version != null && oc.info.version !== '') {
+      brunoConfig.version = ensureString(oc.info.version, '');
+    }
+
     const brunoExtension = (oc.extensions as any)?.bruno;
     if (brunoExtension?.ignore && Array.isArray(brunoExtension.ignore)) {
       brunoConfig.ignore = brunoExtension.ignore;
@@ -32,12 +37,15 @@ const parseCollection = (ymlString: string): ParsedCollection => {
 
     // presets
     if (brunoExtension?.presets) {
-      const presets = brunoExtension.presets as any;
-      if (presets.request) {
+      const presets = brunoExtension.presets as BrunoPresetsExtension;
+      if (presets.request || presets.defaultEnvironment) {
         brunoConfig.presets = {
-          requestType: presets.request.type || [],
-          requestUrl: presets.request.url || []
+          requestType: presets.request?.type || '',
+          requestUrl: presets.request?.url || ''
         };
+        if (presets.defaultEnvironment) {
+          brunoConfig.presets.defaultEnvironment = presets.defaultEnvironment;
+        }
       }
     }
 
@@ -54,6 +62,14 @@ const parseCollection = (ymlString: string): ParsedCollection => {
         };
       }
     }
+    // scripts.flow controls collection/folder/request script execution order
+    // ('sandwich' | 'sequential'); unrecognized values fall back to the runtime default.
+    if (brunoExtensions?.scripts?.flow === 'sandwich' || brunoExtensions?.scripts?.flow === 'sequential') {
+      brunoConfig.scripts = {
+        ...brunoConfig.scripts,
+        flow: brunoExtensions.scripts.flow
+      };
+    }
     if (Array.isArray(brunoExtensions?.openapi) && brunoExtensions.openapi.length > 0) {
       brunoConfig.openapi = brunoExtensions.openapi.map((entry: any) => ({
         sourceUrl: entry.sourceUrl,
@@ -137,14 +153,16 @@ const parseCollection = (ymlString: string): ParsedCollection => {
               type: 'cert',
               certFilePath: cert.certificateFilePath,
               keyFilePath: cert.privateKeyFilePath,
-              passphrase: cert.passphrase || ''
+              passphrase: cert.passphrase || '',
+              ...(cert.disabled === true && { disabled: true })
             };
           } else if (cert.type === 'pkcs12') {
             return {
               domain: cert.domain,
               type: 'pfx',
               pfxFilePath: cert.pkcs12FilePath,
-              passphrase: cert.passphrase || ''
+              passphrase: cert.passphrase || '',
+              ...(cert.disabled === true && { disabled: true })
             };
           }
           return null;

package/src/formats/yml/parseEnvironment.spec.ts

@@ -0,0 +1,99 @@
+import parseEnvironment, { toBrunoEnvironmentVariables } from './parseEnvironment';
+
+describe('toBrunoEnvironmentVariables', () => {
+  it('returns an empty array for null / empty input', () => {
+    expect(toBrunoEnvironmentVariables(null)).toEqual([]);
+    expect(toBrunoEnvironmentVariables(undefined)).toEqual([]);
+    expect(toBrunoEnvironmentVariables([])).toEqual([]);
+  });
+
+  it('parses a plain string variable as text with secret=false', () => {
+    const [variable] = toBrunoEnvironmentVariables([{ name: 'apiKey', value: 'abc' } as any]);
+
+    expect(variable).toMatchObject({
+      name: 'apiKey',
+      value: 'abc',
+      type: 'text',
+      enabled: true,
+      secret: false
+    });
+    expect(variable.uid).toEqual(expect.any(String));
+    expect(variable.dataType).toBeUndefined();
+  });
+
+  it('parses typed values and attaches the dataType field', () => {
+    const vars = toBrunoEnvironmentVariables([
+      { name: 'port', value: { type: 'number', data: '300' } } as any,
+      { name: 'flag', value: { type: 'boolean', data: 'true' } } as any,
+      { name: 'config', value: { type: 'object', data: '{"a":1}' } } as any
+    ]);
+
+    expect(vars[0]).toMatchObject({ name: 'port', value: 300, dataType: 'number', secret: false });
+    expect(vars[1]).toMatchObject({ name: 'flag', value: true, dataType: 'boolean', secret: false });
+    expect(vars[2]).toMatchObject({ name: 'config', value: { a: 1 }, dataType: 'object', secret: false });
+  });
+
+  it('parses secret variables with secret=true and attaches the dataType from `type`', () => {
+    const vars = toBrunoEnvironmentVariables([
+      { secret: true, name: 'apiKey' } as any,
+      { secret: true, name: 'port', type: 'number' } as any,
+      { secret: true, name: 'flag', type: 'boolean', disabled: true } as any
+    ]);
+
+    expect(vars[0]).toMatchObject({ name: 'apiKey', secret: true, enabled: true, value: '' });
+    // A bare secret has no `type`, so no dataType materializes.
+    expect(vars[0].dataType).toBeUndefined();
+    expect(vars[1]).toMatchObject({ name: 'port', secret: true, enabled: true, dataType: 'number' });
+    expect(vars[2]).toMatchObject({ name: 'flag', secret: true, enabled: false, dataType: 'boolean' });
+  });
+
+  it('honors the disabled flag on non-secret variables', () => {
+    const [variable] = toBrunoEnvironmentVariables([
+      { name: 'apiKey', value: 'abc', disabled: true } as any
+    ]);
+
+    expect(variable.enabled).toBe(false);
+  });
+});
+
+describe('parseEnvironment (full yml)', () => {
+  it('parses an environment with mixed plain, typed and secret variables', () => {
+    const yml = `name: test_env
+variables:
+  - name: env_str
+    value: hello
+  - name: env_num
+    value:
+      type: number
+      data: "300"
+  - name: env_bool
+    value:
+      type: boolean
+      data: "true"
+  - name: env_obj
+    value:
+      type: object
+      data: '{"scope":"env"}'
+  - secret: true
+    name: env_secret
+`;
+
+    const env = parseEnvironment(yml);
+
+    expect(env.name).toBe('test_env');
+    expect(env.variables).toHaveLength(5);
+
+    expect(env.variables[0]).toMatchObject({ name: 'env_str', value: 'hello', secret: false });
+    expect(env.variables[1]).toMatchObject({ name: 'env_num', value: 300, dataType: 'number', secret: false });
+    expect(env.variables[2]).toMatchObject({ name: 'env_bool', value: true, dataType: 'boolean', secret: false });
+    expect(env.variables[3]).toMatchObject({ name: 'env_obj', value: { scope: 'env' }, dataType: 'object', secret: false });
+    expect(env.variables[4]).toMatchObject({ name: 'env_secret', secret: true, value: '' });
+    expect(env.variables[4].dataType).toBeUndefined();
+  });
+
+  it('defaults environment name when missing', () => {
+    const env = parseEnvironment('variables: []');
+    expect(env.name).toBe('Untitled Environment');
+    expect(env.variables).toEqual([]);
+  });
+});

package/src/formats/yml/parseEnvironment.ts

@@ -1,20 +1,26 @@
-import type { Environment as BrunoEnvironment, EnvironmentVariable as BrunoEnvironmentVariable } from '@usebruno/schema-types/collection/environment';
+import type {
+  Environment as BrunoEnvironment,
+  EnvironmentVariable as BrunoEnvironmentVariable,
+  SecretEnvironmentVariable as BrunoSecretEnvironmentVariable,
+  ExternalSecretProviderType as BrunoExternalSecretProviderType
+} from '@usebruno/schema-types/collection/environment';
 import type { Environment } from '@opencollection/types/config/environments';
 import type { Variable, SecretVariable } from '@opencollection/types/common/variables';
 import { parseYml } from './utils';
 import { uuid, ensureString } from '../../utils';
-import { isTypedValue } from './common/variables';
+import { SECRET_PROVIDER_IDENTIFIER_FIELDS } from '../../constants';
+import { isTypedValue, fromOpenCollectionTypedValue } from './common/datatype';
 
 const isSecretVariable = (v: Variable | SecretVariable): v is SecretVariable => {
   return 'secret' in v && v.secret === true;
 };
 
-const toBrunoEnvironmentVariables = (variables: (Variable | SecretVariable)[] | null | undefined): BrunoEnvironmentVariable[] => {
+export const toBrunoEnvironmentVariables = (variables: (Variable | SecretVariable)[] | null | undefined): (BrunoEnvironmentVariable | BrunoSecretEnvironmentVariable)[] => {
   if (!variables?.length) {
     return [];
   }
 
-  return variables.map((v): BrunoEnvironmentVariable => {
+  return variables.map((v): (BrunoEnvironmentVariable | BrunoSecretEnvironmentVariable) => {
     if (isSecretVariable(v)) {
       const variable: BrunoEnvironmentVariable = {
         uid: uuid(),
@@ -26,11 +32,16 @@ const toBrunoEnvironmentVariables = (variables: (Variable | SecretVariable)[] |
       };
 
       if (v.type && v.type !== 'string' && v.type !== 'null') {
-        variable.datatype = v.type;
+        variable.dataType = v.type;
+      }
+
+      if (v.description) {
+        variable.description = typeof v.description === 'string' ? v.description : (v.description as any)?.content || '';
       }
 
       return variable;
     }
+
     const variable: BrunoEnvironmentVariable = {
       uid: uuid(),
       name: ensureString(v.name),
@@ -41,36 +52,47 @@ const toBrunoEnvironmentVariables = (variables: (Variable | SecretVariable)[] |
     };
 
     if (isTypedValue(v.value)) {
-      variable.value = ensureString(v.value.data);
-      if (v.value.type !== 'string' && v.value.type !== 'null') {
-        variable.datatype = v.value.type;
-      }
+      Object.assign(variable, fromOpenCollectionTypedValue(v.value));
     } else {
       variable.value = ensureString(v.value);
     }
 
+    if (v.description) {
+      variable.description = typeof v.description === 'string' ? v.description : (v.description as any)?.content || '';
+    }
+
     return variable;
   });
 };
 
+// Parses the yml `externalSecrets: { type, variables: [{ name, path|secretName|vaultName }] }`
+// block into the runtime shape. `uid` and `enabled` are added here; the fetched `value`,
+// `providerConfig` and `lastSyncedAt` are runtime-only and never present in the file.
 const toBrunoExternalSecrets = (externalSecrets: any): BrunoEnvironment['externalSecrets'] | undefined => {
   if (!externalSecrets || typeof externalSecrets !== 'object') {
     return undefined;
   }
 
+  const type = ensureString(externalSecrets.type) as BrunoExternalSecretProviderType;
+  const identifierField = SECRET_PROVIDER_IDENTIFIER_FIELDS[type];
+  if (!identifierField) {
+    return undefined;
+  }
+
+  // Keep any named entry, even one with an empty identifier — a half-filled secret row is the user's
+  // data; dropping it here would silently delete it on the next save.
   const variables = Array.isArray(externalSecrets.variables)
-    ? externalSecrets.variables.map((variable: any) => {
-        const result: Record<string, string> = { name: ensureString(variable?.name) };
-        Object.keys(variable || {}).forEach((key) => {
-          if (key !== 'name') {
-            result[key] = ensureString(variable[key]);
-          }
-        });
-        return result;
-      })
+    ? externalSecrets.variables
+        .filter((v: any) => v && v.name)
+        .map((v: any) => ({
+          uid: uuid(),
+          name: ensureString(v.name),
+          enabled: v.disabled !== true,
+          [identifierField]: ensureString(v[identifierField])
+        }))
     : [];
 
-  return { type: ensureString(externalSecrets.type), variables } as BrunoEnvironment['externalSecrets'];
+  return { type, variables } as BrunoEnvironment['externalSecrets'];
 };
 
 const parseEnvironment = (ymlString: string): BrunoEnvironment => {