@usebruno/filestore 0.5.0 → 0.7.0

package/src/formats/yml/parseCollection.ts

@@ -0,0 +1,220 @@
+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 { toBrunoPostResponseVariables } from './common/actions';
+import { toBrunoScripts } from './common/scripts';
+import { ensureString } from '../../utils';
+
+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: ensureString(oc.info?.name, 'Untitled Collection'),
+      type: 'collection',
+      ignore: []
+    };
+
+    const brunoExtension = (oc.extensions as any)?.bruno;
+    if (brunoExtension?.ignore && Array.isArray(brunoExtension.ignore)) {
+      brunoConfig.ignore = brunoExtension.ignore;
+    }
+
+    // presets
+    if (brunoExtension?.presets) {
+      const presets = brunoExtension.presets as any;
+      if (presets.request) {
+        brunoConfig.presets = {
+          requestType: presets.request.type || [],
+          requestUrl: presets.request.url || []
+        };
+      }
+    }
+
+    // bruno-specific script extensions
+    const brunoExtensions = oc.extensions?.bruno as any;
+    if (Array.isArray(brunoExtensions?.scripts?.additionalContextRoots)) {
+      const sanitizedRoots = brunoExtensions.scripts.additionalContextRoots
+        .filter((item: any) => typeof item === 'string');
+
+      if (sanitizedRoots.length > 0) {
+        brunoConfig.scripts = {
+          ...brunoConfig.scripts,
+          additionalContextRoots: sanitizedRoots
+        };
+      }
+    }
+
+    // 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);
+      const postResponseVars = toBrunoPostResponseVariables((oc.request as any).actions);
+      collectionRoot.request.vars = {
+        req: variables.req,
+        res: postResponseVars
+      };
+
+      // 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,57 @@
+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, ensureString } 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: ensureString(v.name),
+        value: '',
+        type: 'text',
+        enabled: v.disabled !== true,
+        secret: true
+      };
+    }
+    const variable: BrunoEnvironmentVariable = {
+      uid: uuid(),
+      name: ensureString(v.name),
+      value: ensureString(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: ensureString(ocEnvironment.name, 'Untitled Environment'),
+      variables: toBrunoEnvironmentVariables(ocEnvironment.variables),
+      color: ocEnvironment.color || null
+    };
+
+    return brunoEnvironment;
+  } catch (error) {
+    console.error('Error parsing environment:', error);
+    throw error;
+  }
+};
+
+export default parseEnvironment;

package/src/formats/yml/parseFolder.ts

@@ -0,0 +1,93 @@
+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 { toBrunoPostResponseVariables } from './common/actions';
+import { toBrunoScripts } from './common/scripts';
+import { ensureString } from '../../utils';
+
+const parseFolder = (ymlString: string): FolderRoot => {
+  try {
+    const ocFolder: Folder = parseYml(ymlString);
+
+    const info = ocFolder.info;
+
+    const folderRoot: FolderRoot = {
+      meta: {
+        name: ensureString(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);
+      const postResponseVars = toBrunoPostResponseVariables((ocFolder.request as any).actions);
+      folderRoot.request.vars = {
+        req: variables.req,
+        res: postResponseVars
+      };
+
+      // 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;