test(env-file): enhance JSON environment variable persistence tests

- Added a new test to verify the preservation of native typed values in JSON environment files when unrelated keys are touched during script execution.
- Ensured that typed values maintain their original types and are auto-annotated with the correct dataType, validating the integrity of the environment variable persistence process.
- Expanded the typed-value inference tests to cover cross-type transitions, confirming that existing dataType annotations are ignored when new values are written.

Author: sanish-bruno

packages/bruno-cli/tests/integration/run-typed-persistence.spec.js

@@ -434,6 +434,83 @@ script:post-response {
     expect(written).not.toMatch(/name:\s*host[\s\S]*?type:\s*string/);
   }, 60_000);
 
+  // JSON natively supports typed values (`"value": 42`, `"value": true`, `"value": {…}`),
+  // so a JSON env file can seed with real JS types directly — no `dataType` tag needed.
+  // The script then touches an UNRELATED key, which forces the runtime to echo back the
+  // full env map. Every seeded typed value must survive that echo intact — same type, same
+  // value, and `dataType` gets auto-annotated to match the JS type.
+  it('preserves pre-existing native typed values in --env-file JSON when script touches unrelated keys', async () => {
+    writeFixtureFile(
+      path.join(tmpDir, 'bruno.json'),
+      JSON.stringify({ version: '1', name: 'json-types-collection', type: 'collection' }, null, 2) + '\n'
+    );
+    writeFixtureFile(
+      path.join(tmpDir, 'collection.bru'),
+      'meta {\n  name: json-types-collection\n  seq: 1\n}\n'
+    );
+    writeFixtureFile(
+      path.join(tmpDir, 'External.json'),
+      JSON.stringify({
+        name: 'External',
+        variables: [
+          { name: 'host', value: baseUrl },
+          // Native typed values — no dataType tag needed; JSON.parse keeps the JS type.
+          { name: 'seedNum', value: 42 },
+          { name: 'seedBool', value: true },
+          { name: 'seedObj', value: { region: 'eu', port: 3000 } },
+          { name: 'seedArr', value: [1, 2, 3] }
+        ]
+      }, null, 2) + '\n'
+    );
+    writeFixtureFile(
+      path.join(tmpDir, 'touch-unrelated.bru'),
+      `meta {
+  name: touch-unrelated
+  type: http
+  seq: 1
+}
+
+get {
+  url: {{host}}/ping
+  body: none
+  auth: none
+}
+
+script:post-response {
+  bru.setEnvVar("trigger", "x");
+}
+`
+    );
+
+    const result = await runCli([
+      'run', 'touch-unrelated.bru',
+      '--env-file', 'External.json',
+      '--sandbox', 'developer',
+      '--noproxy'
+    ]);
+
+    if (result.code !== 0) {
+      throw new Error(
+        `CLI exited with code ${result.code}.\n--- stdout ---\n${result.stdout}\n--- stderr ---\n${result.stderr}`
+      );
+    }
+
+    const written = JSON.parse(fs.readFileSync(path.join(tmpDir, 'External.json'), 'utf8'));
+    const byName = Object.fromEntries(written.variables.map((v) => [v.name, v]));
+    // Native types preserved AND auto-annotated with dataType matching the JS type.
+    expect(byName.seedNum).toMatchObject({ value: 42, dataType: 'number' });
+    expect(byName.seedBool).toMatchObject({ value: true, dataType: 'boolean' });
+    expect(byName.seedObj).toMatchObject({ value: { region: 'eu', port: 3000 }, dataType: 'object' });
+    // Arrays are `typeof === 'object'` in JS, so they get dataType: 'object'.
+    expect(byName.seedArr).toMatchObject({ value: [1, 2, 3], dataType: 'object' });
+    // String stays string — no dataType added.
+    expect(byName.host.value).toBe(baseUrl);
+    expect(byName.host.dataType).toBeUndefined();
+    // The trigger key the script wrote is also there.
+    expect(byName.trigger).toMatchObject({ value: 'x' });
+    expect(byName.trigger.dataType).toBeUndefined();
+  }, 60_000);
+
   it('persists typed env vars to a --env-file .bru file with @dataType annotations', async () => {
     writeFixtureFile(
       path.join(tmpDir, 'bruno.json'),

packages/bruno-cli/tests/utils/persist-variables.spec.js

@@ -481,6 +481,95 @@ describe('typed-value inference', () => {
   });
 });
 
+// The inference rule (getDataTypeFromValue in @usebruno/common/utils) is purely:
+//   string → drop dataType (string is the implicit default)
+//   number → 'number'
+//   boolean → 'boolean'
+//   object → 'object'  (arrays are typeof 'object' in JS, so they go here too)
+//   null / undefined → 'string' (treated as no-type-info → drop)
+// Existing dataType on disk does NOT influence the inference — only the new JS value's type.
+describe('typed-value inference matrix — dataType derived from the new JS value type', () => {
+  const { parseEnvironment } = require('@usebruno/filestore');
+
+  // Tuple shape: [ label, scriptValue, expectedDataType, expectedValue ]
+  //  - label             : human-readable name interpolated into the test title
+  //  - scriptValue       : the value `bru.setEnvVar('v', X)` puts in the env map
+  //  - expectedDataType  : what `dataType` should end up on disk (or undefined if absent)
+  //  - expectedValue     : what the value should round-trip to through the yml parser
+  it.each([
+    ['string', 'hello', undefined, 'hello'],
+    ['number', 42, 'number', 42],
+    ['number (zero)', 0, 'number', 0],
+    ['boolean (true)', true, 'boolean', true],
+    ['boolean (false)', false, 'boolean', false],
+    ['object', { port: 3000 }, 'object', { port: 3000 }],
+    ['array (typeof object)', [1, 2, 3], 'object', [1, 2, 3]],
+    // null collapses to '' through yml round-trip; the inference rule still treats it as
+    // string (no dataType). undefined behaves the same way.
+    ['null (→ string, empty)', null, undefined, '']
+  ])('script writes %s → on-disk dataType is %s', (_label, value, expectedDataType, expectedValue) => {
+    const filePath = writeFile('inference.yml',
+      'name: t\nvariables:\n  - name: v\n    value: original\n'
+    );
+    persistVariableUpdates(
+      { envVariables: { v: value } },
+      { envFile: { path: filePath, format: 'yml' } }
+    );
+    const reparsed = parseEnvironment(fs.readFileSync(filePath, 'utf8'), { format: 'yml' });
+    expect(reparsed.variables[0].value).toEqual(expectedValue);
+    if (expectedDataType === undefined) {
+      expect(reparsed.variables[0].dataType).toBeUndefined();
+    } else {
+      expect(reparsed.variables[0].dataType).toBe(expectedDataType);
+    }
+  });
+});
+
+// Cross-type transitions: the rule above means inference IGNORES the existing dataType on
+// disk. Whatever type the script writes is what lands on disk. This matters because a
+// user-written `dataType: number` annotation can be silently dropped (or flipped to another
+// type) the first time a script writes a different-typed value to that key.
+describe('typed-value inference: cross-type transitions ignore the existing on-disk dataType', () => {
+  const { parseEnvironment, stringifyEnvironment } = require('@usebruno/filestore');
+
+  const seedYmlEnv = (seedVar) => stringifyEnvironment(
+    {
+      name: 't',
+      variables: [{ name: 'v', enabled: true, secret: false, ...seedVar }]
+    },
+    { format: 'yml' }
+  );
+
+  // Tuple shape: [ label, seed, scriptValue, expected ]
+  //  - label             : human-readable name interpolated into the test title
+  //  - seed              : { value, dataType? } — variable's initial on-disk state.
+  //                        Omit dataType to seed a plain string.
+  //  - scriptValue       : the value `bru.setEnvVar('v', X)` puts in the env map after parse
+  //  - expected          : { value, dataType } end state on disk after persistVariableUpdates;
+  //                        `dataType: undefined` asserts the field is absent on disk
+  it.each([
+    ['number → boolean (annotation flips)', { value: 42, dataType: 'number' }, true, { value: true, dataType: 'boolean' }],
+    ['number → object', { value: 42, dataType: 'number' }, { x: 1 }, { value: { x: 1 }, dataType: 'object' }],
+    ['boolean → number', { value: true, dataType: 'boolean' }, 99, { value: 99, dataType: 'number' }],
+    ['object → string (annotation dropped)', { value: { port: 3000 }, dataType: 'object' }, 'now-a-string', { value: 'now-a-string', dataType: undefined }],
+    ['string → number (annotation added)', { value: 'was-a-string' }, 42, { value: 42, dataType: 'number' }]
+  ])('%s', (_label, seed, scriptValue, expected) => {
+    const filePath = writeFile('xform.yml', seedYmlEnv(seed));
+    persistVariableUpdates(
+      { envVariables: { v: scriptValue } },
+      { envFile: { path: filePath, format: 'yml' } }
+    );
+    const reparsed = parseEnvironment(fs.readFileSync(filePath, 'utf8'), { format: 'yml' });
+    const entry = reparsed.variables[0];
+    expect(entry.value).toEqual(expected.value);
+    if (expected.dataType === undefined) {
+      expect(entry.dataType).toBeUndefined();
+    } else {
+      expect(entry.dataType).toBe(expected.dataType);
+    }
+  });
+});
+
 describe('script-driven typed vars: disk content has the right dataType annotations', () => {
   // The .bru serializer emits `@number\n  port: 3000` (annotation on its own line) — see
   // packages/bruno-lang/v2/src/utils.js serializeAnnotations + serializeVar.