@usebruno/filestore 0.12.0 → 0.13.0

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

@@ -10,7 +10,7 @@ import { toBrunoScripts } from '../common/scripts';
 import { toBrunoAssertions } from '../common/assertions';
 import { uuid, ensureString } from '../../../utils';
 import { utils } from '@usebruno/common';
-const { toBool, toNumber } = utils;
+const { toBool, toMaxRedirects } = utils;
 
 const parseGraphQLRequest = (ocRequest: GraphQLRequest): BrunoItem => {
   const info = ocRequest.info;
@@ -123,7 +123,7 @@ const parseGraphQLRequest = (ocRequest: GraphQLRequest): BrunoItem => {
     }
 
     settings.followRedirects = toBool(ocRequest.settings.followRedirects, true);
-    settings.maxRedirects = toNumber(ocRequest.settings.maxRedirects, 5);
+    settings.maxRedirects = toMaxRedirects(ocRequest.settings.maxRedirects);
     settings.forwardAuthorizationHeader = toBool(ocRequest.settings.forwardAuthorizationHeader, true);
 
     brunoItem.settings = settings;

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

@@ -51,8 +51,10 @@ const parseGrpcRequest = (ocRequest: GrpcRequest): BrunoItem => {
       grpc: []
     },
     script: {
-      req: null,
-      res: null
+      beforeCallStart: null,
+      beforeMessageSend: null,
+      afterMessageReceive: null,
+      afterCallEnd: null
     },
     vars: {
       req: [],
@@ -80,11 +82,17 @@ const parseGrpcRequest = (ocRequest: GrpcRequest): BrunoItem => {
   // scripts
   const scripts = toBrunoScripts(runtime?.scripts);
   if (scripts?.script && brunoRequest.script) {
-    if (scripts.script.req) {
-      brunoRequest.script.req = scripts.script.req;
+    if (scripts.script.beforeCallStart) {
+      brunoRequest.script.beforeCallStart = scripts.script.beforeCallStart;
     }
-    if (scripts.script.res) {
-      brunoRequest.script.res = scripts.script.res;
+    if (scripts.script.beforeMessageSend) {
+      brunoRequest.script.beforeMessageSend = scripts.script.beforeMessageSend;
+    }
+    if (scripts.script.afterMessageReceive) {
+      brunoRequest.script.afterMessageReceive = scripts.script.afterMessageReceive;
+    }
+    if (scripts.script.afterCallEnd) {
+      brunoRequest.script.afterCallEnd = scripts.script.afterCallEnd;
     }
   }
   if (scripts?.tests) {

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

@@ -10,9 +10,10 @@ import { toBrunoPostResponseVariables } from '../common/actions';
 import { toBrunoScripts } from '../common/scripts';
 import { toBrunoAssertions } from '../common/assertions';
 import { toBrunoApp } from '../common/app';
+import { normalizeOmitHeaders } from '../common/omit-headers';
 import { uuid, ensureString } from '../../../utils';
 import { utils } from '@usebruno/common';
-const { toBool, toNumber } = utils;
+const { toBool, toMaxRedirects } = utils;
 
 const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
   const info = ocRequest.info;
@@ -126,9 +127,14 @@ const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
     }
 
     settings.followRedirects = toBool(ocRequest.settings.followRedirects, true);
-    settings.maxRedirects = toNumber(ocRequest.settings.maxRedirects, 5);
+    settings.maxRedirects = toMaxRedirects(ocRequest.settings.maxRedirects);
     settings.forwardAuthorizationHeader = toBool(ocRequest.settings.forwardAuthorizationHeader, true);
 
+    const omitHeaders = normalizeOmitHeaders(ocRequest.settings.omitHeaders);
+    if (omitHeaders) {
+      settings.omitHeaders = omitHeaders;
+    }
+
     brunoItem.settings = settings;
   }
 

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

@@ -8,7 +8,7 @@ import type { Assertion } from '@opencollection/types/common/assertions';
 import type { Action } from '@opencollection/types/common/actions';
 import type { HttpRequestParam, HttpRequestHeader } from '@opencollection/types/requests/http';
 import { stringifyYml } from '../utils';
-import { isNonEmptyString, isNumber } from '../../../utils';
+import { isNonEmptyString } from '../../../utils';
 import { toOpenCollectionAuth } from '../common/auth';
 import { toOpenCollectionHttpHeaders } from '../common/headers';
 import { toOpenCollectionParams } from '../common/params';
@@ -16,7 +16,8 @@ import { toOpenCollectionVariables } from '../common/variables';
 import { toOpenCollectionActions } from '../common/actions';
 import { toOpenCollectionScripts } from '../common/scripts';
 import { toOpenCollectionAssertions } from '../common/assertions';
-import { resolveTimeoutSetting } from '@usebruno/common/utils';
+import { resolveTimeoutSetting, toMaxRedirects } from '@usebruno/common/utils';
+import { HTTP_SCRIPT_KEYS } from '@usebruno/common';
 
 const stringifyGraphQLRequest = (item: BrunoItem): string => {
   try {
@@ -97,7 +98,7 @@ const stringifyGraphQLRequest = (item: BrunoItem): string => {
     }
 
     // scripts
-    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest);
+    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest, HTTP_SCRIPT_KEYS);
     if (scripts) {
       runtime.scripts = scripts;
       hasRuntime = true;
@@ -143,12 +144,7 @@ const stringifyGraphQLRequest = (item: BrunoItem): string => {
       settings.followRedirects = true;
     }
 
-    const maxRedirects = httpSettings?.maxRedirects;
-    if (isNumber(maxRedirects)) {
-      settings.maxRedirects = maxRedirects;
-    } else {
-      settings.maxRedirects = 5;
-    }
+    settings.maxRedirects = toMaxRedirects(httpSettings?.maxRedirects);
 
     settings.forwardAuthorizationHeader = httpSettings?.forwardAuthorizationHeader ?? true;
 

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

@@ -12,6 +12,7 @@ import { toOpenCollectionAuth } from '../common/auth';
 import { toOpenCollectionVariables } from '../common/variables';
 import { toOpenCollectionScripts } from '../common/scripts';
 import { toOpenCollectionAssertions } from '../common/assertions';
+import { GRPC_SCRIPT_KEYS } from '@usebruno/common';
 
 const stringifyGrpcRequest = (item: BrunoItem): string => {
   try {
@@ -103,7 +104,7 @@ const stringifyGrpcRequest = (item: BrunoItem): string => {
     }
 
     // scripts
-    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest);
+    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest, GRPC_SCRIPT_KEYS);
     if (scripts) {
       runtime.scripts = scripts;
       hasRuntime = true;

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

@@ -17,8 +17,10 @@ import { toOpenCollectionVariables } from '../common/variables';
 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';
+import { normalizeOmitHeaders } from '../common/omit-headers';
+import { isNonEmptyString } from '../../../utils';
+import { resolveTimeoutSetting, toMaxRedirects } from '@usebruno/common/utils';
+import { HTTP_SCRIPT_KEYS } from '@usebruno/common';
 
 const stringifyHttpRequest = (item: BrunoItem): string => {
   try {
@@ -85,7 +87,7 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
     }
 
     // scripts
-    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest);
+    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest, HTTP_SCRIPT_KEYS);
     if (scripts) {
       runtime.scripts = scripts;
       hasRuntime = true;
@@ -131,15 +133,15 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
       settings.followRedirects = true;
     }
 
-    const maxRedirects = httpSettings?.maxRedirects;
-    if (isNumber(maxRedirects)) {
-      settings.maxRedirects = maxRedirects;
-    } else {
-      settings.maxRedirects = 5;
-    }
+    settings.maxRedirects = toMaxRedirects(httpSettings?.maxRedirects);
 
     settings.forwardAuthorizationHeader = httpSettings?.forwardAuthorizationHeader ?? true;
 
+    const omitHeaders = normalizeOmitHeaders(httpSettings?.omitHeaders);
+    if (omitHeaders) {
+      settings.omitHeaders = omitHeaders;
+    }
+
     ocRequest.settings = settings;
 
     // examples

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

@@ -11,6 +11,7 @@ import { toOpenCollectionAuth } from '../common/auth';
 import { toOpenCollectionHttpHeaders } from '../common/headers';
 import { toOpenCollectionVariables } from '../common/variables';
 import { toOpenCollectionScripts } from '../common/scripts';
+import { HTTP_SCRIPT_KEYS } from '@usebruno/common';
 
 const stringifyWebsocketRequest = (item: BrunoItem): string => {
   try {
@@ -92,7 +93,8 @@ const stringifyWebsocketRequest = (item: BrunoItem): string => {
     }
 
     // scripts
-    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest);
+    // TODO: Modify to WS scripts once WS scripts are implemented.
+    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest, HTTP_SCRIPT_KEYS);
     if (scripts) {
       runtime.scripts = scripts;
       hasRuntime = true;

package/src/formats/yml/parseCollection.ts

@@ -1,5 +1,6 @@
 import type { OpenCollection } from '@opencollection/types';
 import type { FolderRoot } from '@usebruno/schema-types/collection/folder';
+import { normalizeOpenApiSyncConfigs } from '@usebruno/common';
 import { parseYml } from './utils';
 import { toBrunoAuth } from './common/auth';
 import { toBrunoHttpHeaders } from './common/headers';
@@ -70,15 +71,10 @@ const parseCollection = (ymlString: string): ParsedCollection => {
         flow: brunoExtensions.scripts.flow
       };
     }
-    if (Array.isArray(brunoExtensions?.openapi) && brunoExtensions.openapi.length > 0) {
-      brunoConfig.openapi = brunoExtensions.openapi.map((entry: any) => ({
-        sourceUrl: entry.sourceUrl,
-        groupBy: entry.groupBy,
-        ...(entry.lastSyncDate && { lastSyncDate: entry.lastSyncDate }),
-        ...(entry.specHash && { specHash: entry.specHash }),
-        autoCheck: entry.autoCheck !== false,
-        autoCheckInterval: entry.autoCheckInterval || 5
-      }));
+
+    const openApiEntries = normalizeOpenApiSyncConfigs(brunoExtensions?.openapi);
+    if (openApiEntries.length > 0) {
+      brunoConfig.openapi = openApiEntries;
     }
 
     // protobuf

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

@@ -96,4 +96,53 @@ variables:
     expect(env.name).toBe('Untitled Environment');
     expect(env.variables).toEqual([]);
   });
+
+  describe('extends', () => {
+    it('parses the parent environment name', () => {
+      const env = parseEnvironment(`name: prod
+extends: base
+variables: []
+`);
+
+      expect(env.extends).toBe('base');
+    });
+
+    it('leaves extends absent for an environment that does not declare it', () => {
+      const env = parseEnvironment(`name: prod
+variables: []
+`);
+
+      expect(env).not.toHaveProperty('extends');
+    });
+
+    it('ignores a parent reference that names nothing', () => {
+      const env = parseEnvironment(`name: prod
+extends: "   "
+variables: []
+`);
+
+      expect(env).not.toHaveProperty('extends');
+    });
+
+    it('parses a list of parents unresolved so that a save does not delete it', () => {
+      const env = parseEnvironment(`name: prod
+extends:
+  - base
+  - shared
+variables: []
+`);
+
+      expect(env.extends).toEqual(['base', 'shared']);
+    });
+
+    it('ignores a parent reference that is neither a name nor a list', () => {
+      const env = parseEnvironment(`name: prod
+extends:
+  parent: base
+variables: []
+`);
+
+      expect(env).not.toHaveProperty('extends');
+    });
+  });
 });

package/src/formats/yml/parseEnvironment.ts

@@ -10,6 +10,7 @@ import { parseYml } from './utils';
 import { uuid, ensureString } from '../../utils';
 import { SECRET_PROVIDER_IDENTIFIER_FIELDS } from '../../constants';
 import { isTypedValue, fromOpenCollectionTypedValue } from './common/datatype';
+import { validatedEnvironmentExtendsFrom } from '@usebruno/common/utils';
 
 const isSecretVariable = (v: Variable | SecretVariable): v is SecretVariable => {
   return 'secret' in v && v.secret === true;
@@ -106,6 +107,11 @@ const parseEnvironment = (ymlString: string): BrunoEnvironment => {
       color: ocEnvironment.color || null
     };
 
+    const ocEnvironmentExtendsFrom = validatedEnvironmentExtendsFrom(ocEnvironment.extends);
+    if (ocEnvironmentExtendsFrom) {
+      brunoEnvironment.extends = ocEnvironmentExtendsFrom;
+    }
+
     const externalSecrets = toBrunoExternalSecrets((ocEnvironment as any).externalSecrets);
     if (externalSecrets) {
       brunoEnvironment.externalSecrets = externalSecrets;

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

@@ -0,0 +1,159 @@
+import stringifyItem from './stringifyItem';
+import parseItem from './parseItem';
+import stringifyCollection from './stringifyCollection';
+import parseCollection from './parseCollection';
+import stringifyFolder from './stringifyFolder';
+import parseFolder from './parseFolder';
+
+const GRPC_SLOTS = {
+  beforeCallStart: 'before()',
+  afterCallEnd: 'after()',
+  beforeMessageSend: 'beforeSend()',
+  afterMessageReceive: 'afterReceive()'
+};
+
+const ALL_SLOTS = {
+  req: 'pre()',
+  res: 'post()',
+  ...GRPC_SLOTS
+};
+
+const HTTP_TYPES = ['before-request', 'after-response'];
+const GRPC_TYPES = [
+  'grpc:before-call-start',
+  'grpc:after-call-end',
+  'grpc:before-message-send',
+  'grpc:after-message-receive'
+];
+
+const expectScriptTypes = (yml: string, written: string[], dropped: string[]) => {
+  written.forEach((type) => expect(yml).toContain(`type: ${type}`));
+  dropped.forEach((type) => expect(yml).not.toContain(`type: ${type}`));
+};
+
+const itemWithAllSlots = (type: string, request: Record<string, any>) => ({
+  uid: 'i1',
+  type,
+  name: 'r',
+  seq: 1,
+  request: {
+    auth: { mode: 'none' },
+    headers: [],
+    script: { ...ALL_SLOTS },
+    tests: null,
+    vars: { req: [], res: [] },
+    ...request
+  }
+}) as any;
+
+const rootWithScript = (script: Record<string, string | null>) => ({
+  meta: { name: 'my-folder', seq: 1 },
+  request: {
+    headers: [],
+    auth: { mode: 'none' },
+    script,
+    tests: null,
+    vars: { req: [], res: [] }
+  },
+  docs: null
+}) as any;
+
+describe('script — request items', () => {
+  const httpFamily = [
+    [
+      'http',
+      itemWithAllSlots('http-request', {
+        url: 'https://example.com',
+        method: 'GET',
+        params: [],
+        body: { mode: 'none' }
+      })
+    ],
+    [
+      'graphql',
+      itemWithAllSlots('graphql-request', {
+        url: 'https://example.com/graphql',
+        method: 'POST',
+        params: [],
+        body: { mode: 'graphql', graphql: { query: '{ hi }', variables: '' } }
+      })
+    ],
+    // TODO: Move it to a separate test block, once ws scripts are added.
+    [
+      'websocket',
+      itemWithAllSlots('ws-request', {
+        url: 'wss://example.com',
+        body: { mode: 'ws', ws: [{ name: 'message 1', content: '{}' }] }
+      })
+    ]
+  ] as [string, any][];
+
+  it.each(httpFamily)('a %s request writes req/res and drops the grpc hooks', (_name, item) => {
+    const yml = stringifyItem(item);
+
+    expectScriptTypes(yml, HTTP_TYPES, GRPC_TYPES);
+    expect(yml).not.toContain('before()');
+    expect(yml).not.toContain('after()');
+    expect(yml).not.toContain('beforeSend()');
+    expect(yml).not.toContain('afterReceive()');
+
+    expect(parseItem(yml).request!.script).toEqual({ req: 'pre()', res: 'post()' });
+  });
+
+  it('a grpc request writes the lifecycle hooks and drops req/res', () => {
+    const item = itemWithAllSlots('grpc-request', {
+      url: 'grpc://localhost:50051',
+      method: '/hello.Greeter/SayHello',
+      methodType: 'unary',
+      body: { mode: 'grpc', grpc: [{ name: 'message 1', content: '{}' }] },
+      assertions: []
+    });
+
+    const yml = stringifyItem(item);
+
+    expectScriptTypes(yml, GRPC_TYPES, HTTP_TYPES);
+    expect(yml).not.toContain('pre()');
+    expect(yml).not.toContain('post()');
+
+    expect(parseItem(yml).request!.script).toEqual({
+      beforeCallStart: 'before()',
+      afterCallEnd: 'after()',
+      beforeMessageSend: 'beforeSend()',
+      afterMessageReceive: 'afterReceive()'
+    });
+  });
+});
+
+describe('script — collection and folder roots', () => {
+  it('a collection root writes req/res and drops the grpc hooks', () => {
+    const yml = stringifyCollection(rootWithScript({ ...ALL_SLOTS }), { name: 'c' });
+
+    expectScriptTypes(yml, HTTP_TYPES, GRPC_TYPES);
+
+    expect(parseCollection(yml).collectionRoot.request!.script).toEqual({ req: 'pre()', res: 'post()' });
+  });
+
+  it('a folder root writes req/res and drops the grpc hooks', () => {
+    const yml = stringifyFolder(rootWithScript({ ...ALL_SLOTS }));
+
+    expectScriptTypes(yml, HTTP_TYPES, GRPC_TYPES);
+
+    expect(parseFolder(yml).request!.script).toEqual({ req: 'pre()', res: 'post()' });
+  });
+
+  it('a collection root carrying only grpc hooks writes no scripts at all', () => {
+    const yml = stringifyCollection(rootWithScript({ ...GRPC_SLOTS }), { name: 'c' });
+
+    expect(yml).not.toContain('scripts:');
+
+    expect(parseCollection(yml).collectionRoot.request?.script).toBeUndefined();
+  });
+
+  it('a folder root carrying only grpc hooks writes no scripts at all', () => {
+    const yml = stringifyFolder(rootWithScript({ ...GRPC_SLOTS }));
+
+    expect(yml).not.toContain('scripts:');
+
+    expect(parseFolder(yml).request!.script).toEqual({ req: null, res: null });
+  });
+});

package/src/formats/yml/stringifyCollection.ts

@@ -5,6 +5,7 @@ import type { ClientCertificate, PemCertificate, Pkcs12Certificate } from '@open
 import type { Variable } from '@opencollection/types/common/variables';
 import type { Action } from '@opencollection/types/common/actions';
 import type { Scripts } from '@opencollection/types/common/scripts';
+import { normalizeOpenApiSyncConfigs } from '@usebruno/common';
 import { stringifyYml } from './utils';
 import { toOpenCollectionAuth } from './common/auth';
 import { toOpenCollectionHttpHeaders } from './common/headers';
@@ -12,6 +13,7 @@ import { toOpenCollectionVariables } from './common/variables';
 import { toOpenCollectionActions } from './common/actions';
 import { toOpenCollectionScripts } from './common/scripts';
 import type { Auth } from '@opencollection/types/common/auth';
+import { HTTP_SCRIPT_KEYS } from '@usebruno/common';
 
 const hasCollectionConfig = (brunoConfig: any): boolean => {
   // protobuf
@@ -209,7 +211,8 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
 
       // scripts
       if (hasRequestScripts(collectionRoot)) {
-        const ocScripts: Scripts | undefined = toOpenCollectionScripts(collectionRoot.request);
+        // TODO: Widen scope to include GRPC scripts once Collection/Folder level inheritance is added to gRPC.
+        const ocScripts: Scripts | undefined = toOpenCollectionScripts(collectionRoot.request, HTTP_SCRIPT_KEYS);
         if (ocScripts) {
           oc.request.scripts = ocScripts;
         }
@@ -280,18 +283,12 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
     }
 
     // bruno-specific extensions
-    if (Array.isArray(brunoConfig.openapi) && brunoConfig.openapi.length > 0) {
+    const openApiEntries = normalizeOpenApiSyncConfigs(brunoConfig.openapi);
+    if (openApiEntries.length > 0) {
       if (!oc.extensions.bruno) {
         oc.extensions.bruno = {};
       }
-      (oc.extensions.bruno as any).openapi = brunoConfig.openapi.map((entry: any) => ({
-        sourceUrl: entry.sourceUrl,
-        groupBy: entry.groupBy,
-        ...(entry.lastSyncDate && { lastSyncDate: entry.lastSyncDate }),
-        ...(entry.specHash && { specHash: entry.specHash }),
-        autoCheck: entry.autoCheck !== false,
-        autoCheckInterval: entry.autoCheckInterval || 5
-      }));
+      (oc.extensions.bruno as any).openapi = openApiEntries;
     }
 
     return stringifyYml(oc);

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

@@ -88,4 +88,62 @@ describe('stringifyEnvironment', () => {
     const reparsed = parseEnvironment(stringifyEnvironment(env));
     expect(reparsed.color).toBe('#ff0000');
   });
+
+  describe('extends', () => {
+    it('round-trips the parent environment name', () => {
+      const env = {
+        uid: 'env-uid',
+        name: 'prod',
+        extends: 'base',
+        variables: [{ uid: 'u1', name: 'host', value: 'prod.example.com', type: 'text', enabled: true, secret: false }]
+      } as any;
+
+      const reparsed = parseEnvironment(stringifyEnvironment(env));
+
+      expect(reparsed.extends).toBe('base');
+      expect(reparsed.variables[0]).toMatchObject({ name: 'host', value: 'prod.example.com' });
+    });
+
+    it('omits extends when no parent is set', () => {
+      const env = { uid: 'env-uid', name: 'prod', variables: [] } as any;
+
+      expect(stringifyEnvironment(env)).not.toContain('extends');
+    });
+
+    it('omits extends when the parent names nothing', () => {
+      const env = { uid: 'env-uid', name: 'prod', extends: '  ', variables: [] } as any;
+
+      expect(stringifyEnvironment(env)).not.toContain('extends');
+    });
+
+    it('round-trips a list of parents', () => {
+      const env = { uid: 'env-uid', name: 'prod', extends: ['base', 'shared'], variables: [] } as any;
+
+      const reparsed = parseEnvironment(stringifyEnvironment(env));
+
+      expect(reparsed.extends).toEqual(['base', 'shared']);
+    });
+
+    it('omits extends when the list of parents is empty', () => {
+      const env = { uid: 'env-uid', name: 'prod', extends: [], variables: [] } as any;
+
+      expect(stringifyEnvironment(env)).not.toContain('extends');
+    });
+
+    it('never writes the inheritedFrom provenance of a resolved variable', () => {
+      const env = {
+        uid: 'env-uid',
+        name: 'prod',
+        extends: 'base',
+        variables: [
+          { uid: 'u1', name: 'host', value: 'base.example.com', type: 'text', enabled: true, secret: false, inheritedFrom: 'base' }
+        ]
+      } as any;
+
+      const yml = stringifyEnvironment(env);
+
+      expect(yml).not.toContain('inheritedFrom');
+      expect(parseEnvironment(yml).variables[0]).not.toHaveProperty('inheritedFrom');
+    });
+  });
 });

package/src/formats/yml/stringifyEnvironment.ts

@@ -10,6 +10,7 @@ import { stringifyYml } from './utils';
 import { ensureString } from '../../utils';
 import { SECRET_PROVIDER_IDENTIFIER_FIELDS } from '../../constants';
 import { hasTypedMetadata, toOpenCollectionTypedValue, serializeVariableValue } from './common/datatype';
+import { validatedEnvironmentExtendsFrom } from '@usebruno/common/utils';
 
 export const toOpenCollectionEnvironmentVariables = (variables: (BrunoEnvironmentVariable | BrunoSecretEnvironmentVariable)[]): (Variable | SecretVariable)[] | undefined => {
   if (!variables?.length) {
@@ -90,6 +91,11 @@ const stringifyEnvironment = (environment: BrunoEnvironment): string => {
       name: environment.name
     };
 
+    const environmentExtendsFrom = validatedEnvironmentExtendsFrom(environment.extends);
+    if (environmentExtendsFrom) {
+      (ocEnvironment as any).extends = environmentExtendsFrom;
+    }
+
     if (environment.color) {
       ocEnvironment.color = environment.color;
     }

package/src/formats/yml/stringifyFolder.ts

@@ -12,6 +12,7 @@ import { toOpenCollectionVariables } from './common/variables';
 import { toOpenCollectionActions } from './common/actions';
 import { toOpenCollectionScripts } from './common/scripts';
 import { stringifyYml } from './utils';
+import { HTTP_SCRIPT_KEYS } from '@usebruno/common';
 
 const hasRequestDefaults = (folderRoot: FolderRoot): boolean => {
   const requestDefaults = folderRoot?.request;
@@ -88,7 +89,8 @@ const stringifyFolder = (folderRoot: FolderRoot): string => {
 
       // scripts
       if (hasRequestScripts(folderRoot)) {
-        const ocScripts: Scripts | undefined = toOpenCollectionScripts(folderRoot?.request);
+        // TODO: Widen scope to include GRPC scripts once Collection/Folder level inheritance is added to GRPC.
+        const ocScripts: Scripts | undefined = toOpenCollectionScripts(folderRoot?.request, HTTP_SCRIPT_KEYS);
         if (ocScripts) {
           ocFolder.request.scripts = ocScripts;
         }