@usebruno/filestore 0.5.0 → 0.6.0

package/src/formats/yml/parseCollection.ts

@@ -0,0 +1,198 @@
+import type { OpenCollection } from '@opencollection/types';
+import type { FolderRoot } from '@usebruno/schema-types/collection/folder';
+import { parseYml } from './utils';
+import { toBrunoAuth } from './common/auth';
+import { toBrunoHttpHeaders } from './common/headers';
+import { toBrunoVariables } from './common/variables';
+import { toBrunoScripts } from './common/scripts';
+
+interface ParsedCollection {
+  collectionRoot: FolderRoot;
+  brunoConfig: Record<string, any>;
+}
+
+const parseCollection = (ymlString: string): ParsedCollection => {
+  try {
+    const oc: OpenCollection = parseYml(ymlString);
+
+    // bruno config
+    const brunoConfig: Record<string, any> = {
+      opencollection: oc.opencollection || '1.0.0',
+      name: oc.info?.name || 'Untitled Collection',
+      type: 'collection',
+      ignore: []
+    };
+    if (oc.extensions?.ignore && Array.isArray(oc.extensions.ignore)) {
+      brunoConfig.ignore = oc.extensions.ignore;
+    }
+
+    // presets
+    if (oc.extensions?.presets) {
+      const presets = oc.extensions.presets as any;
+      if (presets.request) {
+        brunoConfig.presets = {
+          requestType: presets.request.type || [],
+          requestUrl: presets.request.url || []
+        };
+      }
+    }
+
+    // protobuf
+    if (oc.config?.protobuf) {
+      brunoConfig.protobuf = {
+        protofFiles: oc.config.protobuf.protoFiles?.map((protoFile: any) => ({
+          path: protoFile.path
+        })) || [],
+        importPaths: oc.config.protobuf.importPaths?.map((importPath: any) => ({
+          path: importPath.path,
+          disabled: importPath.disabled || false
+        })) || []
+      };
+    }
+
+    // proxy - only support newer format
+    // Default: inherit from global preferences
+    brunoConfig.proxy = {
+      inherit: true,
+      config: {
+        protocol: 'http',
+        hostname: '',
+        port: '',
+        auth: {
+          username: '',
+          password: ''
+        },
+        bypassProxy: ''
+      }
+    };
+
+    if (oc.config?.proxy && typeof oc.config.proxy === 'object') {
+      // Validate newer format: must have 'inherit' and 'config' properties
+      const proxyConfig = oc.config.proxy as any;
+
+      if ('inherit' in proxyConfig && typeof proxyConfig.inherit === 'boolean' && proxyConfig.config && typeof proxyConfig.config === 'object') {
+        // Valid newer format
+        brunoConfig.proxy = {
+          inherit: proxyConfig.inherit,
+          config: {
+            protocol: proxyConfig.config.protocol || 'http',
+            hostname: proxyConfig.config.hostname || '',
+            port: proxyConfig.config.port || '',
+            auth: {
+              username: proxyConfig.config.auth?.username || '',
+              password: proxyConfig.config.auth?.password || ''
+            },
+            bypassProxy: proxyConfig.config.bypassProxy || ''
+          }
+        };
+
+        // Handle optional disabled field
+        if (proxyConfig.disabled === true) {
+          brunoConfig.proxy.disabled = true;
+        }
+
+        // Handle optional auth.disabled field
+        if (proxyConfig.config.auth?.disabled === true) {
+          brunoConfig.proxy.config.auth.disabled = true;
+        }
+      }
+      // If not in newer format, use default (inherit: true)
+    }
+
+    // client certificates
+    if (oc.config?.clientCertificates?.length) {
+      brunoConfig.clientCertificates = {
+        certs: oc.config.clientCertificates.map((cert: any) => {
+          if (cert.type === 'pem') {
+            return {
+              domain: cert.domain,
+              type: 'cert',
+              certFilePath: cert.certificateFilePath,
+              keyFilePath: cert.privateKeyFilePath,
+              passphrase: cert.passphrase || ''
+            };
+          } else if (cert.type === 'pkcs12') {
+            return {
+              domain: cert.domain,
+              type: 'pfx',
+              pfxFilePath: cert.pkcs12FilePath,
+              passphrase: cert.passphrase || ''
+            };
+          }
+          return null;
+        }).filter((cert: any) => cert !== null)
+      };
+    }
+
+    // collection root
+    const collectionRoot: FolderRoot = {
+      meta: null,
+      request: null,
+      docs: null
+    };
+
+    // request defaults
+    if (oc.request) {
+      collectionRoot.request = {
+        headers: null,
+        auth: null,
+        script: {
+          req: null,
+          res: null
+        },
+        vars: {
+          req: [],
+          res: []
+        },
+        tests: null
+      };
+
+      // headers
+      const headers = toBrunoHttpHeaders(oc.request.headers);
+      collectionRoot.request.headers = headers || [];
+
+      // auth
+      const auth = toBrunoAuth(oc.request.auth);
+      if (auth) {
+        collectionRoot.request.auth = auth;
+      }
+
+      // variables
+      const variables = toBrunoVariables(oc.request.variables);
+      collectionRoot.request.vars = variables;
+
+      // scripts
+      const scripts = toBrunoScripts(oc.request.scripts);
+      if (scripts?.script && collectionRoot.request.script) {
+        if (scripts.script.req) {
+          collectionRoot.request.script.req = scripts.script.req;
+        }
+        if (scripts.script.res) {
+          collectionRoot.request.script.res = scripts.script.res;
+        }
+      }
+      if (scripts?.tests) {
+        collectionRoot.request.tests = scripts.tests;
+      }
+    }
+
+    // docs
+    if (oc.docs) {
+      if (typeof oc.docs === 'string') {
+        collectionRoot.docs = oc.docs;
+      } else if (typeof oc.docs === 'object' && oc.docs.content) {
+        collectionRoot.docs = oc.docs.content;
+      }
+    }
+
+    return {
+      collectionRoot,
+      brunoConfig
+    };
+  } catch (error) {
+    console.error('Error parsing collection:', error);
+    throw error;
+  }
+};
+
+export default parseCollection;

package/src/formats/yml/parseEnvironment.ts

@@ -0,0 +1,56 @@
+import type { Environment as BrunoEnvironment, EnvironmentVariable as BrunoEnvironmentVariable } 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 } from '../../utils';
+
+const isSecretVariable = (v: Variable | SecretVariable): v is SecretVariable => {
+  return 'secret' in v && v.secret === true;
+};
+
+const toBrunoEnvironmentVariables = (variables: (Variable | SecretVariable)[] | null | undefined): BrunoEnvironmentVariable[] => {
+  if (!variables?.length) {
+    return [];
+  }
+
+  return variables.map((v): BrunoEnvironmentVariable => {
+    if (isSecretVariable(v)) {
+      return {
+        uid: uuid(),
+        name: v.name || '',
+        value: '',
+        type: 'text',
+        enabled: v.disabled !== true,
+        secret: true
+      };
+    }
+    const variable: BrunoEnvironmentVariable = {
+      uid: uuid(),
+      name: v.name || '',
+      value: (typeof v.value === 'string' ? v.value : '') || '',
+      type: 'text',
+      enabled: v.disabled !== true,
+      secret: false
+    };
+    return variable;
+  });
+};
+
+const parseEnvironment = (ymlString: string): BrunoEnvironment => {
+  try {
+    const ocEnvironment: Environment = parseYml(ymlString);
+
+    const brunoEnvironment: BrunoEnvironment = {
+      uid: uuid(),
+      name: ocEnvironment.name || 'Untitled Environment',
+      variables: toBrunoEnvironmentVariables(ocEnvironment.variables)
+    };
+
+    return brunoEnvironment;
+  } catch (error) {
+    console.error('Error parsing environment:', error);
+    throw error;
+  }
+};
+
+export default parseEnvironment;

package/src/formats/yml/parseFolder.ts

@@ -0,0 +1,88 @@
+import type { FolderRoot } from '@usebruno/schema-types/collection/folder';
+import type { Folder } from '@opencollection/types/collection/item';
+import { parseYml } from './utils';
+import { toBrunoAuth } from './common/auth';
+import { toBrunoHttpHeaders } from './common/headers';
+import { toBrunoVariables } from './common/variables';
+import { toBrunoScripts } from './common/scripts';
+import { isNonEmptyString } from '../../utils';
+
+const parseFolder = (ymlString: string): FolderRoot => {
+  try {
+    const ocFolder: Folder = parseYml(ymlString);
+
+    const info = ocFolder.info;
+
+    const folderRoot: FolderRoot = {
+      meta: {
+        name: info?.name || 'Untitled Folder',
+        seq: info?.seq || 1
+      },
+      request: null,
+      docs: null
+    };
+
+    // request defaults
+    if (ocFolder.request) {
+      folderRoot.request = {
+        headers: [],
+        auth: null,
+        script: {
+          req: null,
+          res: null
+        },
+        vars: {
+          req: [],
+          res: []
+        },
+        tests: null
+      };
+
+      // headers
+      const headers = toBrunoHttpHeaders(ocFolder.request.headers);
+      if (headers) {
+        folderRoot.request.headers = headers;
+      }
+
+      // auth
+      const auth = toBrunoAuth(ocFolder.request.auth);
+      if (auth) {
+        folderRoot.request.auth = auth;
+      }
+
+      // variables
+      const variables = toBrunoVariables(ocFolder.request.variables);
+      folderRoot.request.vars = variables;
+
+      // scripts
+      const scripts = toBrunoScripts(ocFolder.request.scripts);
+      if (scripts?.script && folderRoot.request.script) {
+        if (scripts.script.req) {
+          folderRoot.request.script.req = scripts.script.req;
+        }
+        if (scripts.script.res) {
+          folderRoot.request.script.res = scripts.script.res;
+        }
+      }
+      if (scripts?.tests) {
+        folderRoot.request.tests = scripts.tests;
+      }
+    }
+
+    // docs (now at root level)
+    if (ocFolder.docs) {
+      if (typeof ocFolder.docs === 'string' && ocFolder.docs.trim().length) {
+        folderRoot.docs = ocFolder.docs;
+      } else if (typeof ocFolder.docs === 'object' && ocFolder.docs.content?.trim().length) {
+        folderRoot.docs = ocFolder.docs.content;
+      }
+    }
+
+    return folderRoot;
+  } catch (error) {
+    console.error('Error parsing folder:', error);
+    throw error;
+  }
+};
+
+export default parseFolder;

package/src/formats/yml/parseItem.ts

@@ -0,0 +1,102 @@
+import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
+import type { Item, ScriptFile } from '@opencollection/types/collection/item';
+import type { HttpRequest } from '@opencollection/types/requests/http';
+import type { GraphQLRequest } from '@opencollection/types/requests/graphql';
+import type { GrpcRequest } from '@opencollection/types/requests/grpc';
+import type { WebSocketRequest } from '@opencollection/types/requests/websocket';
+import { parseYml } from './utils';
+import parseHttpRequest from './items/parseHttpRequest';
+import parseGraphQLRequest from './items/parseGraphQLRequest';
+import parseGrpcRequest from './items/parseGrpcRequest';
+import parseWebsocketRequest from './items/parseWebsocketRequest';
+import parseScript from './items/parseScript';
+
+// Helper to get the type from an item (now in info block)
+const getItemType = (item: Item): string | undefined => {
+  if ('info' in item && item.info && 'type' in item.info) {
+    return item.info.type;
+  }
+  // For ScriptFile which still has type at root
+  if ('type' in item) {
+    return (item as ScriptFile).type;
+  }
+  return undefined;
+};
+
+/**
+ * In v3.0.0-rc1 release auth was present under runtime property for all requests
+ * This has now been moved to the respective request properties
+ * This backward compatibility has been put in place for folks who tried out our early preview
+ * Should be safe to remove this in 3 months. Delete after 5 Apr 2026
+ */
+const ensureAuthV3Rc1BackwardsCompatibility = (parsedItemYml: any): any => {
+  const itemType = parsedItemYml?.info?.type;
+
+  switch (itemType) {
+    case 'http':
+      if (parsedItemYml.runtime?.auth && !parsedItemYml.http?.auth) {
+        parsedItemYml.http.auth = parsedItemYml.runtime.auth;
+      }
+      break;
+    case 'graphql':
+      if (parsedItemYml.runtime?.auth && !parsedItemYml.graphql?.auth) {
+        parsedItemYml.graphql.auth = parsedItemYml.runtime.auth;
+      }
+      break;
+    case 'grpc':
+      if (parsedItemYml.runtime?.auth && !parsedItemYml.grpc?.auth) {
+        parsedItemYml.grpc.auth = parsedItemYml.runtime.auth;
+      }
+      break;
+    case 'websocket':
+      if (parsedItemYml.runtime?.auth && !parsedItemYml.websocket?.auth) {
+        parsedItemYml.websocket.auth = parsedItemYml.runtime.auth;
+      }
+      break;
+    default:
+      break;
+  }
+
+  return parsedItemYml;
+};
+
+const parseItem = (ymlString: string): BrunoItem => {
+  try {
+    const parsedYml = parseYml(ymlString);
+
+    const ocItem: Item = ensureAuthV3Rc1BackwardsCompatibility(parsedYml);
+    const itemType = getItemType(ocItem);
+
+    if (!ocItem || !itemType) {
+      throw new Error('Invalid item: missing type');
+    }
+
+    switch (itemType) {
+      case 'http':
+        return parseHttpRequest(ocItem as HttpRequest);
+
+      case 'graphql':
+        return parseGraphQLRequest(ocItem as GraphQLRequest);
+
+      case 'grpc':
+        return parseGrpcRequest(ocItem as GrpcRequest);
+
+      case 'websocket':
+        return parseWebsocketRequest(ocItem as WebSocketRequest);
+
+      case 'script':
+        return parseScript(ocItem as ScriptFile);
+
+      case 'folder':
+        throw new Error('Folder items should be handled separately using parseFolder');
+
+      default:
+        throw new Error(`Unsupported item type: ${itemType}`);
+    }
+  } catch (error) {
+    console.error('Error parsing item:', error);
+    throw error;
+  }
+};
+
+export default parseItem;

package/src/formats/yml/stringifyCollection.ts

@@ -0,0 +1,230 @@
+import type { OpenCollection } from '@opencollection/types';
+import type { ProtoFileItem, ProtoFileImportPath } from '@opencollection/types/config/protobuf';
+import type { HttpRequestHeader } from '@opencollection/types/requests/http';
+import type { ClientCertificate, PemCertificate, Pkcs12Certificate } from '@opencollection/types/config/certificates';
+import type { Variable } from '@opencollection/types/common/variables';
+import type { Scripts } from '@opencollection/types/common/scripts';
+import { stringifyYml } from './utils';
+import { toOpenCollectionAuth } from './common/auth';
+import { toOpenCollectionHttpHeaders } from './common/headers';
+import { toOpenCollectionVariables } from './common/variables';
+import { toOpenCollectionScripts } from './common/scripts';
+import type { Auth } from '@opencollection/types/common/auth';
+
+const hasCollectionConfig = (brunoConfig: any): boolean => {
+  // protobuf
+  const hasProtobuf = (
+    brunoConfig.protobuf?.protofFiles?.length > 0
+    || brunoConfig.protobuf?.importPaths?.length > 0
+  );
+
+  // proxy - check if proxy is configured in newer format
+  // Valid newer format: has 'inherit' property and 'config' object
+  const isValidProxyFormat = brunoConfig.proxy
+    && typeof brunoConfig.proxy === 'object'
+    && 'inherit' in brunoConfig.proxy
+    && brunoConfig.proxy.config
+    && typeof brunoConfig.proxy.config === 'object';
+
+  const hasProxy = isValidProxyFormat;
+
+  // client certificates
+  const hasClientCertificates = brunoConfig.clientCertificates?.certs?.length > 0;
+
+  return hasProtobuf || hasProxy || hasClientCertificates;
+};
+
+const hasRequestDefaults = (collectionRoot: any): boolean => {
+  const requestRoot = collectionRoot?.request;
+
+  return Boolean((requestRoot?.headers?.length)
+    || (requestRoot?.vars?.req?.length)
+    || hasRequestScripts(collectionRoot)
+    || hasRequestAuth(collectionRoot));
+};
+
+const hasRequestAuth = (collectionRoot: any): boolean => {
+  return Boolean((collectionRoot.request?.auth?.mode !== 'none'));
+};
+
+const hasRequestScripts = (collectionRoot: any): boolean => {
+  return (collectionRoot.request?.script?.req)
+    || (collectionRoot.request?.script?.res)
+    || (collectionRoot.request?.tests);
+};
+
+const hasPresets = (brunoConfig: any): boolean => {
+  return brunoConfig?.presets?.requestType?.length
+    || brunoConfig?.presets?.requestUrl?.length;
+};
+
+const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
+  try {
+    const oc: OpenCollection = {};
+
+    oc.opencollection = '1.0.0';
+    oc.info = {
+      name: brunoConfig.name || 'Untitled Collection'
+    };
+
+    // collection config
+    if (hasCollectionConfig(brunoConfig)) {
+      oc.config = {};
+
+      if (brunoConfig.protobuf?.protofFiles?.length) {
+        oc.config.protobuf = {
+          protoFiles: brunoConfig.protobuf.protofFiles.map((protoFile: any): ProtoFileItem => ({
+            type: 'file' as const,
+            path: protoFile.path
+          })),
+          importPaths: brunoConfig.protobuf.importPaths.map((importPath: any): ProtoFileImportPath => ({
+            path: importPath.path,
+            disabled: importPath.disabled
+          }))
+        };
+      }
+
+      // proxy - only write newer format
+      // Validate that brunoConfig.proxy is in newer format before writing
+      const isValidProxyFormat = brunoConfig.proxy
+        && typeof brunoConfig.proxy === 'object'
+        && 'inherit' in brunoConfig.proxy
+        && brunoConfig.proxy.config
+        && typeof brunoConfig.proxy.config === 'object';
+
+      if (isValidProxyFormat) {
+        oc.config.proxy = {
+          inherit: brunoConfig.proxy.inherit,
+          config: {
+            protocol: brunoConfig.proxy.config.protocol || 'http',
+            hostname: brunoConfig.proxy.config.hostname || '',
+            port: brunoConfig.proxy.config.port || '',
+            auth: {
+              username: brunoConfig.proxy.config.auth?.username || '',
+              password: brunoConfig.proxy.config.auth?.password || ''
+            },
+            bypassProxy: brunoConfig.proxy.config.bypassProxy || ''
+          }
+        };
+
+        // Add optional disabled field if true
+        if (brunoConfig.proxy.disabled === true) {
+          oc.config.proxy.disabled = true;
+        }
+
+        // Add optional auth.disabled field if true
+        if (brunoConfig.proxy.config?.auth?.disabled === true) {
+          if (oc.config.proxy.config && oc.config.proxy.config.auth) {
+            oc.config.proxy.config.auth.disabled = true;
+          }
+        }
+      }
+
+      // client certificates
+      if (brunoConfig.clientCertificates?.certs?.length) {
+        oc.config.clientCertificates = brunoConfig.clientCertificates.certs
+          .map((cert: any): ClientCertificate | null => {
+            if (cert.type === 'pem') {
+              const pemCert: PemCertificate = {
+                domain: cert.domain,
+                type: 'pem',
+                certificateFilePath: cert.certFilePath,
+                privateKeyFilePath: cert.keyFilePath,
+                ...(cert.passphrase && { passphrase: cert.passphrase })
+              };
+              return pemCert;
+            } else if (cert.type === 'pkcs12') {
+              const pkcs12Cert: Pkcs12Certificate = {
+                domain: cert.domain,
+                type: 'pkcs12',
+                pkcs12FilePath: cert.pfxFilePath,
+                ...(cert.passphrase && { passphrase: cert.passphrase })
+              };
+              return pkcs12Cert;
+            } else {
+              // Unsupported certificate type - ignore silently
+              return null;
+            }
+          })
+          .filter((cert: ClientCertificate | null): cert is ClientCertificate => cert !== null);
+      }
+    }
+
+    // request defaults
+    if (hasRequestDefaults(collectionRoot)) {
+      oc.request = {};
+
+      // headers
+      if (collectionRoot.request?.headers?.length) {
+        const ocHeaders: HttpRequestHeader[] | undefined = toOpenCollectionHttpHeaders(collectionRoot.request?.headers);
+        if (ocHeaders) {
+          oc.request.headers = ocHeaders;
+        }
+      }
+
+      // auth
+      if (hasRequestAuth(collectionRoot)) {
+        const ocAuth: Auth | undefined = toOpenCollectionAuth(collectionRoot.request?.auth);
+        if (ocAuth) {
+          oc.request.auth = ocAuth;
+        }
+      }
+
+      // variables
+      if (collectionRoot.request?.vars?.req?.length) {
+        const ocVariables: Variable[] | undefined = toOpenCollectionVariables(collectionRoot.request?.vars);
+        if (ocVariables) {
+          oc.request.variables = ocVariables;
+        }
+      }
+
+      // scripts
+      if (hasRequestScripts(collectionRoot)) {
+        const ocScripts: Scripts | undefined = toOpenCollectionScripts(collectionRoot.request);
+        if (ocScripts) {
+          oc.request.scripts = ocScripts;
+        }
+      }
+    }
+
+    // docs
+    if (collectionRoot.docs?.trim().length) {
+      oc.docs = {
+        content: collectionRoot.docs,
+        type: 'text/markdown'
+      };
+    }
+
+    // bundled
+    oc.bundled = false;
+
+    // extensions
+    oc.extensions = {};
+    if (brunoConfig.ignore?.length) {
+      const ignoreList: string[] = [];
+      brunoConfig.ignore.forEach((ignore: string) => {
+        ignoreList.push(ignore);
+      });
+      oc.extensions.ignore = ignoreList;
+    }
+    if (hasPresets(brunoConfig)) {
+      const presetsRequest: any = {};
+      if (brunoConfig.presets.requestType?.length) {
+        presetsRequest.type = brunoConfig.presets.requestType;
+      }
+      if (brunoConfig.presets.requestUrl?.length) {
+        presetsRequest.url = brunoConfig.presets.requestUrl;
+      }
+      oc.extensions.presets = {
+        request: presetsRequest
+      } as any;
+    }
+
+    return stringifyYml(oc);
+  } catch (error) {
+    console.error('Error stringifying opencollection.yml:', error);
+    throw error;
+  }
+};
+
+export default stringifyCollection;