@usebruno/filestore 0.10.0 → 0.12.0

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

@@ -0,0 +1,223 @@
+import stringifyCollection from './stringifyCollection';
+import parseCollection from './parseCollection';
+
+// Typed collection-root vars serialize to OC's `{ type, data }` struct.
+// `dataType: 'string'` is the implicit default and stays a raw string.
+
+describe('stringifyCollection — typed request.variables', () => {
+  it('round-trips typed values and omits a typed struct for the implicit string default', () => {
+    const collectionRoot = {
+      meta: null,
+      request: {
+        headers: [],
+        auth: { mode: 'none' },
+        script: { req: null, res: null },
+        tests: null,
+        vars: {
+          req: [
+            { uid: 'v1', name: 'count', value: 42, enabled: true, dataType: 'number' },
+            { uid: 'v2', name: 'enabled', value: true, enabled: true, dataType: 'boolean' },
+            { uid: 'v3', name: 'config', value: { a: 1 }, enabled: true, dataType: 'object' },
+            { uid: 'v4', name: 'greeting', value: 'hi', enabled: true, dataType: 'string' },
+            { uid: 'v5', name: 'plain', value: 'hello', enabled: true }
+          ],
+          res: []
+        }
+      },
+      docs: null
+    } as any;
+
+    const brunoConfig = { name: 'c' };
+
+    const yml = stringifyCollection(collectionRoot, brunoConfig);
+
+    // `type: string` is never written out.
+    expect(yml).not.toMatch(/type:\s*string/);
+
+    const { collectionRoot: reparsed } = parseCollection(yml);
+    const reqVars = reparsed.request!.vars!.req!;
+
+    expect(reqVars).toHaveLength(5);
+    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' });
+    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();
+  });
+});
+
+describe('stringifyCollection — script execution flow', () => {
+  const baseRoot = {
+    meta: null,
+    request: { headers: [], auth: { mode: 'none' }, script: { req: null, res: null }, tests: null, vars: { req: [], res: [] } },
+    docs: null
+  } as any;
+
+  it('round-trips flow: sequential through the bruno extension', () => {
+    const yml = stringifyCollection(baseRoot, { name: 'c', scripts: { flow: 'sequential' } });
+    expect(yml).toMatch(/flow:\s*sequential/);
+    expect(parseCollection(yml).brunoConfig.scripts?.flow).toBe('sequential');
+  });
+
+  it('round-trips flow: sandwich through the bruno extension', () => {
+    const yml = stringifyCollection(baseRoot, { name: 'c', scripts: { flow: 'sandwich' } });
+    expect(parseCollection(yml).brunoConfig.scripts?.flow).toBe('sandwich');
+  });
+
+  it('writes no flow when the collection has none', () => {
+    const yml = stringifyCollection(baseRoot, { name: 'c' });
+    expect(yml).not.toMatch(/flow:/);
+    expect(parseCollection(yml).brunoConfig.scripts?.flow).toBeUndefined();
+  });
+
+  it('drops an unrecognized flow value on write', () => {
+    const yml = stringifyCollection(baseRoot, { name: 'c', scripts: { flow: 'parallel' } });
+    expect(yml).not.toMatch(/flow:/);
+  });
+
+  it('preserves additionalContextRoots alongside a written flow value', () => {
+    const yml = stringifyCollection(baseRoot, {
+      name: 'c',
+      scripts: { flow: 'sequential', additionalContextRoots: ['../libs'] }
+    });
+    const { brunoConfig } = parseCollection(yml);
+    expect(brunoConfig.scripts?.flow).toBe('sequential');
+    expect(brunoConfig.scripts?.additionalContextRoots).toEqual(['../libs']);
+  });
+});
+
+describe('stringifyCollection — client certificates', () => {
+  const baseRoot = {
+    meta: null,
+    request: { headers: [], auth: { mode: 'none' }, script: { req: null, res: null }, tests: null, vars: { req: [], res: [] } },
+    docs: null
+  } as any;
+
+  it('round-trips cert/pfx certificates', () => {
+    const brunoConfig = {
+      name: 'c',
+      clientCertificates: {
+        certs: [
+          {
+            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: ''
+          }
+        ]
+      }
+    };
+
+    const yml = stringifyCollection(baseRoot, brunoConfig);
+    const { brunoConfig: reparsed } = parseCollection(yml);
+
+    expect(reparsed.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('writes disabled: true for disabled certs and round-trips it', () => {
+    const brunoConfig = {
+      name: 'c',
+      clientCertificates: {
+        certs: [
+          {
+            domain: 'localhost',
+            type: 'cert',
+            certFilePath: './certs/client-cert.pem',
+            keyFilePath: './certs/client-key.pem',
+            passphrase: 'secret',
+            disabled: true
+          },
+          {
+            domain: 'example.com',
+            type: 'pfx',
+            pfxFilePath: './certs/client.pfx',
+            passphrase: '',
+            disabled: true
+          }
+        ]
+      }
+    };
+
+    const yml = stringifyCollection(baseRoot, brunoConfig);
+
+    expect(yml).toMatch(/disabled:\s*true/);
+
+    const { brunoConfig: reparsed } = parseCollection(yml);
+    expect(reparsed.clientCertificates.certs[0].disabled).toBe(true);
+    expect(reparsed.clientCertificates.certs[1].disabled).toBe(true);
+  });
+
+  it('does not write disabled for enabled certs', () => {
+    const brunoConfig = {
+      name: 'c',
+      clientCertificates: {
+        certs: [
+          {
+            domain: 'example.com',
+            type: 'pfx',
+            pfxFilePath: './certs/client.pfx',
+            passphrase: ''
+          }
+        ]
+      }
+    };
+
+    const yml = stringifyCollection(baseRoot, brunoConfig);
+
+    expect(yml).not.toMatch(/disabled:/);
+
+    const { brunoConfig: reparsed } = parseCollection(yml);
+    expect(reparsed.clientCertificates.certs[0]).not.toHaveProperty('disabled');
+  });
+});
+
+describe('stringifyCollection — writing the collection version', () => {
+  const baseRoot = {
+    meta: null,
+    request: { headers: [], auth: { mode: 'none' }, script: { req: null, res: null }, tests: null, vars: { req: [], res: [] } },
+    docs: null
+  } as any;
+
+  it('writes the version as-is and reads back the same value', () => {
+    const yml = stringifyCollection(baseRoot, { name: 'c', version: '2' });
+    expect(yml).toMatch(/version:\s*['"]?2['"]?/);
+    expect(parseCollection(yml).brunoConfig.version).toBe('2');
+  });
+
+  it('writes no version when the collection has none', () => {
+    const yml = stringifyCollection(baseRoot, { name: 'c' });
+    expect(parseCollection(yml).brunoConfig.version).toBeUndefined();
+  });
+
+  it('accepts any version text — there is no check on the format', () => {
+    // The version is free-form: users can set whatever they like. Each of these should be
+    // saved and read back exactly the same, without changing the format or rejecting it.
+    ['v1.0.0', '2', '1.2.3-beta', '2024.01.15', 'release-2024-Q3', 'anything-goes'].forEach((version) => {
+      const yml = stringifyCollection(baseRoot, { name: 'c', version });
+      expect(parseCollection(yml).brunoConfig.version).toBe(version);
+    });
+  });
+});

package/src/formats/yml/stringifyCollection.ts

@@ -61,7 +61,8 @@ const hasRequestScripts = (collectionRoot: any): boolean => {
 
 const hasPresets = (brunoConfig: any): boolean => {
   return brunoConfig?.presets?.requestType?.length
-    || brunoConfig?.presets?.requestUrl?.length;
+    || brunoConfig?.presets?.requestUrl?.length
+    || brunoConfig?.presets?.defaultEnvironment?.length;
 };
 
 const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
@@ -73,6 +74,10 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
       name: brunoConfig.name || 'Untitled Collection'
     };
 
+    if (brunoConfig.version != null && brunoConfig.version !== '') {
+      oc.info.version = String(brunoConfig.version);
+    }
+
     // collection config
     if (hasCollectionConfig(brunoConfig)) {
       oc.config = {};
@@ -144,7 +149,8 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
                 type: 'pem',
                 certificateFilePath: cert.certFilePath,
                 privateKeyFilePath: cert.keyFilePath,
-                ...(cert.passphrase && { passphrase: cert.passphrase })
+                ...(cert.passphrase && { passphrase: cert.passphrase }),
+                ...(cert.disabled === true && { disabled: true })
               };
               return pemCert;
             } else if (cert.type === 'pfx') {
@@ -152,7 +158,8 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
                 domain: cert.domain,
                 type: 'pkcs12',
                 pkcs12FilePath: cert.pfxFilePath,
-                ...(cert.passphrase && { passphrase: cert.passphrase })
+                ...(cert.passphrase && { passphrase: cert.passphrase }),
+                ...(cert.disabled === true && { disabled: true })
               };
               return pkcs12Cert;
             } else {
@@ -237,6 +244,7 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
       }
 
       if (hasPresets(brunoConfig)) {
+        const presetsExtension: any = {};
         const presetsRequest: any = {};
         if (brunoConfig.presets.requestType?.length) {
           presetsRequest.type = brunoConfig.presets.requestType;
@@ -244,22 +252,31 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
         if (brunoConfig.presets.requestUrl?.length) {
           presetsRequest.url = brunoConfig.presets.requestUrl;
         }
-        brunoExtension.presets = {
-          request: presetsRequest
-        };
+        if (Object.keys(presetsRequest).length) {
+          presetsExtension.request = presetsRequest;
+        }
+        if (brunoConfig.presets.defaultEnvironment?.length) {
+          presetsExtension.defaultEnvironment = brunoConfig.presets.defaultEnvironment;
+        }
+        brunoExtension.presets = presetsExtension;
       }
 
       oc.extensions.bruno = brunoExtension;
     }
 
     // bruno-specific script extensions
+    const brunoScripts: Record<string, unknown> = {};
     if (brunoConfig.scripts?.additionalContextRoots?.length) {
+      brunoScripts.additionalContextRoots = brunoConfig.scripts.additionalContextRoots;
+    }
+    if (brunoConfig.scripts?.flow === 'sandwich' || brunoConfig.scripts?.flow === 'sequential') {
+      brunoScripts.flow = brunoConfig.scripts.flow;
+    }
+    if (Object.keys(brunoScripts).length > 0) {
       if (!oc.extensions.bruno) {
         oc.extensions.bruno = {};
       }
-      (oc.extensions.bruno as any).scripts = {
-        additionalContextRoots: brunoConfig.scripts.additionalContextRoots
-      };
+      (oc.extensions.bruno as any).scripts = brunoScripts;
     }
 
     // bruno-specific extensions

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

@@ -0,0 +1,91 @@
+import stringifyEnvironment, { toOpenCollectionEnvironmentVariables } from './stringifyEnvironment';
+import parseEnvironment from './parseEnvironment';
+
+describe('toOpenCollectionEnvironmentVariables', () => {
+  it('returns undefined for null / empty input', () => {
+    expect(toOpenCollectionEnvironmentVariables([])).toBeUndefined();
+  });
+
+  it('serializes plain string variables as raw strings', () => {
+    const out = toOpenCollectionEnvironmentVariables([
+      { uid: 'u1', name: 'apiKey', value: 'abc', type: 'text', enabled: true, secret: false } as any
+    ]);
+
+    expect(out).toEqual([{ name: 'apiKey', value: 'abc' }]);
+  });
+
+  it('serializes typed variables as a {type, data} struct', () => {
+    const out = toOpenCollectionEnvironmentVariables([
+      { uid: 'u1', name: 'port', value: 300, type: 'text', enabled: true, secret: false, dataType: 'number' } as any,
+      { uid: 'u2', name: 'flag', value: true, type: 'text', enabled: true, secret: false, dataType: 'boolean' } as any,
+      { uid: 'u3', name: 'config', value: { a: 1 }, type: 'text', enabled: true, secret: false, dataType: 'object' } as any
+    ]);
+
+    expect(out).toEqual([
+      { name: 'port', value: { type: 'number', data: '300' } },
+      { name: 'flag', value: { type: 'boolean', data: 'true' } },
+      { name: 'config', value: { type: 'object', data: '{\n  "a": 1\n}' } }
+    ]);
+  });
+
+  it('serializes secret variables without a value but preserves the dataType as `type`', () => {
+    const out = toOpenCollectionEnvironmentVariables([
+      { uid: 'u1', name: 'apiKey', value: '', type: 'text', enabled: true, secret: true } as any,
+      { uid: 'u2', name: 'flag', value: '', type: 'text', enabled: false, secret: true, dataType: 'number' } as any
+    ]);
+
+    expect(out).toEqual([
+      { secret: true, name: 'apiKey' },
+      { secret: true, name: 'flag', type: 'number', disabled: true }
+    ]);
+  });
+
+  it('marks disabled non-secret variables', () => {
+    const out = toOpenCollectionEnvironmentVariables([
+      { uid: 'u1', name: 'apiKey', value: 'abc', type: 'text', enabled: false, secret: false } as any
+    ]);
+
+    expect(out).toEqual([{ name: 'apiKey', value: 'abc', disabled: true }]);
+  });
+});
+
+describe('stringifyEnvironment', () => {
+  it('round-trips through parseEnvironment for typed and secret variables', () => {
+    const env = {
+      uid: 'env-uid',
+      name: 'test_env',
+      variables: [
+        { uid: 'u1', name: 'env_str', value: 'hello', type: 'text', enabled: true, secret: false },
+        { uid: 'u2', name: 'env_num', value: 300, type: 'text', enabled: true, secret: false, dataType: 'number' as const },
+        { uid: 'u3', name: 'env_bool', value: true, type: 'text', enabled: true, secret: false, dataType: 'boolean' as const },
+        { uid: 'u4', name: 'env_obj', value: { scope: 'env' }, type: 'text', enabled: true, secret: false, dataType: 'object' as const },
+        { uid: 'u5', name: 'env_secret', value: '', type: 'text', enabled: true, secret: true },
+        { uid: 'u6', name: 'env_secret_num', value: '', type: 'text', enabled: true, secret: true, dataType: 'number' as const }
+      ]
+    } as any;
+
+    const yml = stringifyEnvironment(env);
+    const reparsed = parseEnvironment(yml);
+
+    expect(reparsed.name).toBe('test_env');
+    expect(reparsed.variables[0]).toMatchObject({ name: 'env_str', value: 'hello', secret: false });
+    expect(reparsed.variables[1]).toMatchObject({ name: 'env_num', value: 300, dataType: 'number', secret: false });
+    expect(reparsed.variables[2]).toMatchObject({ name: 'env_bool', value: true, dataType: 'boolean', secret: false });
+    expect(reparsed.variables[3]).toMatchObject({ name: 'env_obj', value: { scope: 'env' }, dataType: 'object', secret: false });
+    expect(reparsed.variables[4]).toMatchObject({ name: 'env_secret', secret: true, value: '' });
+    expect(reparsed.variables[4].dataType).toBeUndefined();
+    expect(reparsed.variables[5]).toMatchObject({ name: 'env_secret_num', secret: true, value: '', dataType: 'number' });
+  });
+
+  it('preserves the color field when present', () => {
+    const env = {
+      uid: 'env-uid',
+      name: 'colorful',
+      color: '#ff0000',
+      variables: []
+    } as any;
+
+    const reparsed = parseEnvironment(stringifyEnvironment(env));
+    expect(reparsed.color).toBe('#ff0000');
+  });
+});

package/src/formats/yml/stringifyEnvironment.ts

@@ -1,53 +1,89 @@
-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 { stringifyYml } from './utils';
 import { ensureString } from '../../utils';
+import { SECRET_PROVIDER_IDENTIFIER_FIELDS } from '../../constants';
+import { hasTypedMetadata, toOpenCollectionTypedValue, serializeVariableValue } from './common/datatype';
 
-const toOpenCollectionEnvironmentVariables = (variables: BrunoEnvironmentVariable[]): (Variable | SecretVariable)[] | undefined => {
+export const toOpenCollectionEnvironmentVariables = (variables: (BrunoEnvironmentVariable | BrunoSecretEnvironmentVariable)[]): (Variable | SecretVariable)[] | undefined => {
   if (!variables?.length) {
     return undefined;
   }
 
   const ocVariables: (Variable | SecretVariable)[] = variables
-    .filter((v: BrunoEnvironmentVariable) => {
-      // todo: currently neither bru lang nor bruno app supports non-string values
-      // update this when bruno app supports non-string values
-      return typeof v.value === 'string';
-    })
-    .map((v: BrunoEnvironmentVariable): Variable | SecretVariable => {
-      if (v.secret === true) {
+    .map((v): Variable | SecretVariable => {
+      if ('secret' in v && v.secret === true) {
         const secretVar: SecretVariable = {
           secret: true,
           name: v.name || ''
         };
-        if (v.datatype && v.datatype !== 'string') {
-          secretVar.type = v.datatype;
+        if (hasTypedMetadata(v)) {
+          secretVar.type = v.dataType;
         }
         if (v.enabled === false) {
           secretVar.disabled = true;
         }
+        if (v.description !== undefined) {
+          secretVar.description = v.description;
+        }
         return secretVar;
       }
 
+      const valueStr = serializeVariableValue(v.value);
+
       const variable: Variable = {
         name: v.name || '',
-        value:
-          v.datatype && v.datatype !== 'string'
-            ? { type: v.datatype, data: ensureString(v.value) }
-            : ensureString(v.value)
+        value: hasTypedMetadata(v) ? toOpenCollectionTypedValue(v, valueStr) : valueStr
       };
 
       if (v.enabled === false) {
         variable.disabled = true;
       }
 
+      if (v.description !== undefined) {
+        variable.description = v.description;
+      }
+
       return variable;
     });
 
   return ocVariables.length > 0 ? ocVariables : undefined;
 };
 
+// Serializes the runtime externalSecrets block to yml `{ type, variables: [{ name,
+// path|secretName|vaultName, disabled? }] }`. Runtime-only fields (uid, value,
+// providerConfig, lastSyncedAt) are never written.
+const toOpenCollectionExternalSecrets = (externalSecrets: BrunoEnvironment['externalSecrets']): { type: string; variables: Record<string, string | boolean>[] } | undefined => {
+  const type = externalSecrets?.type as BrunoExternalSecretProviderType | undefined;
+  const identifierField = type && SECRET_PROVIDER_IDENTIFIER_FIELDS[type];
+  if (!type || !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 = (externalSecrets?.variables || [])
+    .filter((v: any) => v && v.name)
+    .map((v: any) => {
+      const secret: Record<string, string | boolean> = {
+        name: v.name,
+        [identifierField]: ensureString(v[identifierField])
+      };
+      if (v.enabled === false) {
+        secret.disabled = true;
+      }
+      return secret;
+    });
+
+  return { type, variables };
+};
+
 const stringifyEnvironment = (environment: BrunoEnvironment): string => {
   try {
     const ocEnvironment: Environment = {
@@ -65,11 +101,9 @@ const stringifyEnvironment = (environment: BrunoEnvironment): string => {
       }
     }
 
-    if (environment.externalSecrets) {
-      (ocEnvironment as any).externalSecrets = {
-        type: environment.externalSecrets.type,
-        variables: (environment.externalSecrets.variables || []).map((variable) => ({ ...variable }))
-      };
+    const ocExternalSecrets = toOpenCollectionExternalSecrets(environment.externalSecrets);
+    if (ocExternalSecrets) {
+      (ocEnvironment as any).externalSecrets = ocExternalSecrets;
     }
 
     return stringifyYml(ocEnvironment);
@@ -78,4 +112,5 @@ const stringifyEnvironment = (environment: BrunoEnvironment): string => {
     throw error;
   }
 };
+
 export default stringifyEnvironment;

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

@@ -0,0 +1,70 @@
+import stringifyFolder from './stringifyFolder';
+import parseFolder from './parseFolder';
+
+// Typed folder vars serialize to OC's `{ type, data }` struct.
+// `dataType: 'string'` is the implicit default and stays a raw string.
+
+describe('stringifyFolder — typed request.variables', () => {
+  it('round-trips typed values and omits a typed struct for the implicit string default', () => {
+    const folderRoot = {
+      meta: { name: 'my-folder', seq: 1 },
+      request: {
+        headers: [],
+        auth: { mode: 'none' },
+        script: { req: null, res: null },
+        tests: null,
+        vars: {
+          req: [
+            { uid: 'v1', name: 'count', value: 42, enabled: true, dataType: 'number' },
+            { uid: 'v2', name: 'enabled', value: true, enabled: true, dataType: 'boolean' },
+            { uid: 'v3', name: 'config', value: { a: 1 }, enabled: true, dataType: 'object' },
+            { uid: 'v4', name: 'greeting', value: 'hi', enabled: true, dataType: 'string' },
+            { uid: 'v5', name: 'plain', value: 'hello', enabled: true }
+          ],
+          res: []
+        }
+      },
+      docs: null
+    } as any;
+
+    const yml = stringifyFolder(folderRoot);
+
+    // `type: string` is never written out.
+    expect(yml).not.toMatch(/type:\s*string/);
+
+    const reparsed = parseFolder(yml);
+    const reqVars = reparsed.request!.vars!.req!;
+
+    expect(reqVars).toHaveLength(5);
+    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' });
+    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();
+  });
+});
+
+describe('stringifyFolder — seq', () => {
+  it('omits seq when the folder has none', () => {
+    const folderRoot = { meta: { name: 'no-seq-folder' }, docs: null } as any;
+
+    const yml = stringifyFolder(folderRoot);
+    const { meta } = parseFolder(yml);
+
+    expect(yml).not.toMatch(/seq:/);
+    expect(meta).toEqual(expect.objectContaining({ name: 'no-seq-folder' }));
+    expect(meta!.seq).toBeUndefined();
+  });
+
+  it('preserves an explicit numeric seq', () => {
+    const folderRoot = { meta: { name: 'ordered-folder', seq: 3 }, docs: null } as any;
+
+    const yml = stringifyFolder(folderRoot);
+    const { meta } = parseFolder(yml);
+
+    expect(meta).toEqual(expect.objectContaining({ name: 'ordered-folder' }));
+    expect(meta!.seq).toBe(3);
+  });
+});

package/src/formats/yml/stringifyFolder.ts

@@ -40,9 +40,14 @@ const stringifyFolder = (folderRoot: FolderRoot): string => {
     // info block
     const info: FolderInfo = {
       name: folderRoot.meta?.name || 'Untitled Folder',
-      type: 'folder',
-      seq: folderRoot.meta?.seq || 1
+      type: 'folder'
     };
+    // Only write seq when the folder actually has a numeric one. Defaulting to 1 would
+    // force every seq-less folder into position 1 on disk and break alphabetical fallback.
+    const seq = folderRoot.meta?.seq;
+    if (typeof seq === 'number' && Number.isFinite(seq)) {
+      info.seq = seq;
+    }
     ocFolder.info = info;
 
     // request defaults

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

@@ -0,0 +1,53 @@
+import stringifyItem from './stringifyItem';
+import parseItem from './parseItem';
+
+// Typed bruno vars on `request.vars.req` serialize to OC's `{ type, data }`
+// struct. `dataType: 'string'` is the implicit default and stays a raw string.
+
+describe('stringifyItem — typed runtime.variables', () => {
+  it('round-trips typed values and omits a typed struct for the implicit string default', () => {
+    const item = {
+      uid: 'i1',
+      type: 'http-request',
+      name: 'r',
+      seq: 1,
+      request: {
+        url: 'https://example.com',
+        method: 'GET',
+        headers: [],
+        params: [],
+        body: { mode: 'none' },
+        auth: { mode: 'none' },
+        script: { req: null, res: null },
+        tests: null,
+        vars: {
+          req: [
+            { uid: 'v1', name: 'count', value: 42, enabled: true, dataType: 'number' },
+            { uid: 'v2', name: 'enabled', value: true, enabled: true, dataType: 'boolean' },
+            { uid: 'v3', name: 'config', value: { a: 1 }, enabled: true, dataType: 'object' },
+            { uid: 'v4', name: 'greeting', value: 'hi', enabled: true, dataType: 'string' },
+            { uid: 'v5', name: 'plain', value: 'hello', enabled: true }
+          ],
+          res: []
+        }
+      }
+    } as any;
+
+    const yml = stringifyItem(item);
+
+    // `type: string` is never written out.
+    expect(yml).not.toMatch(/type:\s*string/);
+
+    const reparsed = parseItem(yml);
+    const reqVars = reparsed.request!.vars!.req!;
+
+    expect(reqVars).toHaveLength(5);
+    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' });
+    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();
+  });
+});