@usebruno/filestore 0.4.0 → 0.6.0

package/src/formats/yml/common/variables.ts

@@ -0,0 +1,68 @@
+import { Variable } from '@opencollection/types/common/variables';
+import { FolderRequest as BrunoFolderRequest } from '@usebruno/schema-types/collection/folder';
+import { Variable as BrunoVariable, Variables as BrunoVariables } from '@usebruno/schema-types/common/variables';
+import { uuid } from '../../../utils';
+
+/**
+ * Convert Bruno pre-request variables to OpenCollection variables format.
+ * Note: Post-response variables are now converted to actions (see actions.ts).
+ */
+export const toOpenCollectionVariables = (variables: BrunoFolderRequest['vars'] | BrunoVariables | null | undefined): Variable[] | undefined => {
+  // Handle folder variables (has req/res structure) - only use req vars
+  const hasReqRes = variables && 'req' in variables;
+  const reqVars = hasReqRes ? variables.req : variables as BrunoVariables;
+
+  const reqVarsArray = Array.isArray(reqVars) ? reqVars : [];
+
+  if (!reqVarsArray.length) {
+    return undefined;
+  }
+
+  const ocVariables: Variable[] = reqVarsArray.map((v: BrunoVariable): Variable => {
+    const variable: Variable = {
+      name: v.name || '',
+      value: v.value || ''
+    };
+
+    if (v?.description?.trim().length) {
+      variable.description = v.description;
+    }
+
+    if (v.enabled === false) {
+      variable.disabled = true;
+    }
+    return variable;
+  });
+
+  return ocVariables.length > 0 ? ocVariables : undefined;
+};
+
+/**
+ * Convert OpenCollection variables to Bruno pre-request variables format.
+ * Note: Post-response variables come from actions (see actions.ts).
+ */
+export const toBrunoVariables = (variables: Variable[] | null | undefined): { req: BrunoVariables; res: BrunoVariables } => {
+  if (!variables?.length) {
+    return { req: [], res: [] };
+  }
+
+  const reqVars: BrunoVariables = [];
+
+  variables.forEach((v: Variable) => {
+    const variable: BrunoVariable = {
+      uid: uuid(),
+      name: v.name || '',
+      value: v.value as string || '',
+      enabled: v.disabled !== true,
+      local: false
+    };
+
+    if (v.description) {
+      variable.description = typeof v.description === 'string' ? v.description : (v.description as any)?.content || '';
+    }
+
+    reqVars.push(variable);
+  });
+
+  return { req: reqVars, res: [] };
+};

package/src/formats/yml/index.ts

@@ -0,0 +1,20 @@
+import parseYmlItem from './parseItem';
+import parseYmlFolder from './parseFolder';
+import parseYmlCollection from './parseCollection';
+import parseYmlEnvironment from './parseEnvironment';
+
+import stringifyYmlItem from './stringifyItem';
+import stringifyYmlFolder from './stringifyFolder';
+import stringifyYmlCollection from './stringifyCollection';
+import stringifyYmlEnvironment from './stringifyEnvironment';
+
+export {
+  parseYmlItem,
+  parseYmlFolder,
+  parseYmlCollection,
+  parseYmlEnvironment,
+  stringifyYmlItem,
+  stringifyYmlFolder,
+  stringifyYmlCollection,
+  stringifyYmlEnvironment
+};

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

@@ -0,0 +1,137 @@
+import type { Item as BrunoItem, HttpItemSettings as BrunoHttpItemSettings } from '@usebruno/schema-types/collection/item';
+import type { HttpRequest as BrunoHttpRequest } from '@usebruno/schema-types/requests/http';
+import type { GraphQLRequest, GraphQLRequestSettings, GraphQLBody } from '@opencollection/types/requests/graphql';
+import { toBrunoAuth } from '../common/auth';
+import { toBrunoHttpHeaders } from '../common/headers';
+import { toBrunoParams } from '../common/params';
+import { toBrunoVariables } from '../common/variables';
+import { toBrunoPostResponseVariables } from '../common/actions';
+import { toBrunoScripts } from '../common/scripts';
+import { toBrunoAssertions } from '../common/assertions';
+import { uuid } from '../../../utils';
+
+const parseGraphQLRequest = (ocRequest: GraphQLRequest): BrunoItem => {
+  const info = ocRequest.info;
+  const graphql = ocRequest.graphql;
+  const runtime = ocRequest.runtime;
+
+  const brunoRequest: BrunoHttpRequest = {
+    url: graphql?.url || '',
+    method: graphql?.method || 'POST',
+    headers: toBrunoHttpHeaders(graphql?.headers) || [],
+    params: toBrunoParams(graphql?.params) || [],
+    auth: toBrunoAuth(graphql?.auth),
+    body: {
+      mode: 'graphql',
+      json: null,
+      text: null,
+      xml: null,
+      sparql: null,
+      formUrlEncoded: [],
+      multipartForm: [],
+      graphql: {
+        query: (graphql?.body as GraphQLBody)?.query || '',
+        variables: (graphql?.body as GraphQLBody)?.variables || ''
+      },
+      file: []
+    },
+    script: {
+      req: null,
+      res: null
+    },
+    vars: {
+      req: [],
+      res: []
+    },
+    assertions: [],
+    tests: null,
+    docs: null
+  };
+
+  // scripts
+  const scripts = toBrunoScripts(runtime?.scripts);
+  if (scripts?.script && brunoRequest.script) {
+    if (scripts.script.req) {
+      brunoRequest.script.req = scripts.script.req;
+    }
+    if (scripts.script.res) {
+      brunoRequest.script.res = scripts.script.res;
+    }
+  }
+  if (scripts?.tests) {
+    brunoRequest.tests = scripts.tests;
+  }
+
+  // variables (pre-request from variables, post-response from actions)
+  const variables = toBrunoVariables(runtime?.variables);
+  const postResponseVars = toBrunoPostResponseVariables(runtime?.actions);
+  brunoRequest.vars = {
+    req: variables.req,
+    res: postResponseVars
+  };
+
+  // assertions
+  const assertions = toBrunoAssertions(runtime?.assertions);
+  if (assertions) {
+    brunoRequest.assertions = assertions;
+  }
+
+  // docs
+  if (ocRequest.docs) {
+    brunoRequest.docs = ocRequest.docs;
+  }
+
+  // bruno item
+  const brunoItem: BrunoItem = {
+    uid: uuid(),
+    type: 'graphql-request',
+    seq: info?.seq || 1,
+    name: info?.name || 'Untitled Request',
+    tags: info?.tags || [],
+    request: brunoRequest,
+    settings: null,
+    fileContent: null,
+    root: null,
+    items: [],
+    examples: [],
+    filename: null,
+    pathname: null
+  };
+
+  // settings
+  if (ocRequest.settings) {
+    const settings: BrunoHttpItemSettings = {};
+
+    if (typeof ocRequest.settings.encodeUrl === 'boolean') {
+      settings.encodeUrl = ocRequest.settings.encodeUrl;
+    } else {
+      settings.encodeUrl = true;
+    }
+
+    if (typeof ocRequest.settings.timeout === 'number') {
+      settings.timeout = ocRequest.settings.timeout;
+    } else if (ocRequest.settings.timeout === 'inherit') {
+      settings.timeout = 'inherit';
+    } else {
+      settings.timeout = 0;
+    }
+
+    if (typeof ocRequest.settings.followRedirects === 'boolean') {
+      settings.followRedirects = ocRequest.settings.followRedirects;
+    } else {
+      settings.followRedirects = true;
+    }
+
+    if (typeof ocRequest.settings.maxRedirects === 'number') {
+      settings.maxRedirects = ocRequest.settings.maxRedirects;
+    } else {
+      settings.maxRedirects = 5;
+    }
+
+    brunoItem.settings = settings;
+  }
+
+  return brunoItem;
+};
+
+export default parseGraphQLRequest;

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

@@ -0,0 +1,116 @@
+import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
+import type { GrpcRequest as BrunoGrpcRequest } from '@usebruno/schema-types/requests/grpc';
+import type { GrpcRequest, GrpcMetadata } from '@opencollection/types/requests/grpc';
+import type { KeyValue as BrunoKeyValue } from '@usebruno/schema-types/common/key-value';
+import { toBrunoAuth } from '../common/auth';
+import { toBrunoVariables } from '../common/variables';
+import { toBrunoScripts } from '../common/scripts';
+import { toBrunoAssertions } from '../common/assertions';
+import { isNonEmptyString, uuid } from '../../../utils';
+
+const toBrunoGrpcMetadata = (metadata: GrpcMetadata[] | null | undefined): BrunoKeyValue[] | undefined => {
+  if (!metadata?.length) {
+    return undefined;
+  }
+
+  const brunoMetadata = metadata.map((meta: GrpcMetadata): BrunoKeyValue => {
+    const brunoMeta: BrunoKeyValue = {
+      uid: uuid(),
+      name: meta.name || '',
+      value: meta.value || '',
+      enabled: meta.disabled !== true
+    };
+
+    return brunoMeta;
+  });
+
+  return brunoMetadata.length ? brunoMetadata : undefined;
+};
+
+const parseGrpcRequest = (ocRequest: GrpcRequest): BrunoItem => {
+  const info = ocRequest.info;
+  const grpc = ocRequest.grpc;
+  const runtime = ocRequest.runtime;
+
+  const brunoRequest: BrunoGrpcRequest = {
+    url: grpc?.url || '',
+    method: grpc?.method || '',
+    methodType: grpc?.methodType || '',
+    protoPath: grpc?.protoFilePath || null,
+    headers: toBrunoGrpcMetadata(grpc?.metadata) || [],
+    auth: toBrunoAuth(grpc?.auth),
+    body: {
+      mode: 'grpc',
+      grpc: []
+    },
+    script: {
+      req: null,
+      res: null
+    },
+    vars: {
+      req: [],
+      res: []
+    },
+    assertions: [],
+    tests: null,
+    docs: null
+  };
+
+  // message
+  if (isNonEmptyString(grpc?.message)) {
+    brunoRequest.body.grpc = [{
+      name: '',
+      content: grpc?.message as string
+    }];
+  }
+
+  // scripts
+  const scripts = toBrunoScripts(runtime?.scripts);
+  if (scripts?.script && brunoRequest.script) {
+    if (scripts.script.req) {
+      brunoRequest.script.req = scripts.script.req;
+    }
+    if (scripts.script.res) {
+      brunoRequest.script.res = scripts.script.res;
+    }
+  }
+  if (scripts?.tests) {
+    brunoRequest.tests = scripts.tests;
+  }
+
+  // variables
+  const variables = toBrunoVariables(runtime?.variables);
+  brunoRequest.vars = variables;
+
+  // assertions
+  const assertions = toBrunoAssertions(runtime?.assertions);
+  if (assertions) {
+    brunoRequest.assertions = assertions;
+  }
+
+  // docs
+  if (ocRequest.docs) {
+    brunoRequest.docs = ocRequest.docs;
+  }
+
+  // bruno item
+  const brunoItem: BrunoItem = {
+    uid: uuid(),
+    type: 'grpc-request',
+    seq: info?.seq || 1,
+    name: info?.name || 'Untitled Request',
+    tags: info?.tags || [],
+    request: brunoRequest,
+    settings: {},
+    fileContent: null,
+    root: null,
+    items: [],
+    examples: [],
+    filename: null,
+    pathname: null
+  };
+
+  return brunoItem;
+};
+
+export default parseGrpcRequest;

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

@@ -0,0 +1,195 @@
+import type { Item as BrunoItem, HttpItemSettings as BrunoHttpItemSettings } from '@usebruno/schema-types/collection/item';
+import type { HttpRequest as BrunoHttpRequest } from '@usebruno/schema-types/requests/http';
+import type { HttpRequest, HttpRequestBody } from '@opencollection/types/requests/http';
+import { toBrunoAuth } from '../common/auth';
+import { toBrunoHttpHeaders } from '../common/headers';
+import { toBrunoParams } from '../common/params';
+import { toBrunoBody } from '../common/body';
+import { toBrunoVariables } from '../common/variables';
+import { toBrunoPostResponseVariables } from '../common/actions';
+import { toBrunoScripts } from '../common/scripts';
+import { toBrunoAssertions } from '../common/assertions';
+import { uuid } from '../../../utils';
+
+const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
+  const info = ocRequest.info;
+  const http = ocRequest.http;
+  const runtime = ocRequest.runtime;
+
+  const brunoRequest: BrunoHttpRequest = {
+    url: http?.url || '',
+    method: http?.method || 'GET',
+    headers: toBrunoHttpHeaders(http?.headers) || [],
+    params: toBrunoParams(http?.params) || [],
+    auth: toBrunoAuth(http?.auth),
+    body: toBrunoBody(http?.body as HttpRequestBody) || {
+      mode: 'none',
+      json: null,
+      text: null,
+      xml: null,
+      sparql: null,
+      formUrlEncoded: [],
+      multipartForm: [],
+      graphql: null,
+      file: []
+    },
+    script: {
+      req: null,
+      res: null
+    },
+    vars: {
+      req: [],
+      res: []
+    },
+    assertions: [],
+    tests: null,
+    docs: null
+  };
+
+  // scripts
+  const scripts = toBrunoScripts(runtime?.scripts);
+  if (scripts?.script && brunoRequest.script) {
+    if (scripts.script.req) {
+      brunoRequest.script.req = scripts.script.req;
+    }
+    if (scripts.script.res) {
+      brunoRequest.script.res = scripts.script.res;
+    }
+  }
+  if (scripts?.tests) {
+    brunoRequest.tests = scripts.tests;
+  }
+
+  // variables (pre-request from variables, post-response from actions)
+  const variables = toBrunoVariables(runtime?.variables);
+  const postResponseVars = toBrunoPostResponseVariables(runtime?.actions);
+  brunoRequest.vars = {
+    req: variables.req,
+    res: postResponseVars
+  };
+
+  // assertions
+  const assertions = toBrunoAssertions(runtime?.assertions);
+  if (assertions) {
+    brunoRequest.assertions = assertions;
+  }
+
+  // docs
+  if (ocRequest.docs) {
+    brunoRequest.docs = ocRequest.docs;
+  }
+
+  // bruno item
+  const brunoItem: BrunoItem = {
+    uid: uuid(),
+    type: 'http-request',
+    seq: info?.seq || 1,
+    name: info?.name || 'Untitled Request',
+    tags: info?.tags || [],
+    request: brunoRequest,
+    settings: null,
+    fileContent: null,
+    root: null,
+    items: [],
+    examples: [],
+    filename: null,
+    pathname: null
+  };
+
+  // settings
+  if (ocRequest.settings) {
+    const settings: BrunoHttpItemSettings = {};
+
+    if (typeof ocRequest.settings.encodeUrl === 'boolean') {
+      settings.encodeUrl = ocRequest.settings.encodeUrl;
+    } else {
+      settings.encodeUrl = true;
+    }
+
+    if (typeof ocRequest.settings.timeout === 'number') {
+      settings.timeout = ocRequest.settings.timeout;
+    } else if (ocRequest.settings.timeout === 'inherit') {
+      settings.timeout = 'inherit';
+    } else {
+      settings.timeout = 0;
+    }
+
+    if (typeof ocRequest.settings.followRedirects === 'boolean') {
+      settings.followRedirects = ocRequest.settings.followRedirects;
+    } else {
+      settings.followRedirects = true;
+    }
+
+    if (typeof ocRequest.settings.maxRedirects === 'number') {
+      settings.maxRedirects = ocRequest.settings.maxRedirects;
+    } else {
+      settings.maxRedirects = 5;
+    }
+
+    brunoItem.settings = settings;
+  }
+
+  // examples
+  if (ocRequest.examples?.length) {
+    brunoItem.examples = ocRequest.examples.map((example) => {
+      const brunoExample: any = {
+        uid: uuid(),
+        itemUid: uuid(),
+        name: example.name || 'Untitled Example',
+        type: 'http-request',
+        request: null,
+        response: null
+      };
+
+      if (example.description) {
+        if (typeof example.description === 'string' && example.description.trim().length) {
+          brunoExample.description = example.description;
+        } else if (typeof example.description === 'object' && example.description.content?.trim().length) {
+          brunoExample.description = example.description.content;
+        }
+      }
+
+      if (example.request) {
+        brunoExample.request = {
+          url: example.request.url || '',
+          method: example.request.method || 'GET',
+          headers: toBrunoHttpHeaders(example.request.headers) || [],
+          params: toBrunoParams(example.request.params) || [],
+          body: toBrunoBody(example.request.body) || {
+            mode: 'none',
+            json: null,
+            text: null,
+            xml: null,
+            sparql: null,
+            formUrlEncoded: null,
+            multipartForm: null,
+            graphql: null,
+            file: null
+          }
+        };
+      }
+
+      if (example.response) {
+        brunoExample.response = {
+          status: example.response.status !== undefined ? String(example.response.status) : null,
+          statusText: example.response.statusText || null,
+          headers: toBrunoHttpHeaders(example.response.headers) || [],
+          body: null
+        };
+
+        if (example.response.body) {
+          brunoExample.response.body = {
+            type: example.response.body.type || 'text',
+            content: example.response.body.data || ''
+          };
+        }
+      }
+
+      return brunoExample;
+    });
+  }
+
+  return brunoItem;
+};
+
+export default parseHttpRequest;

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

@@ -0,0 +1,25 @@
+import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
+import type { ScriptFile } from '@opencollection/types/collection/item';
+import { uuid } from '../../../utils';
+
+const parseScript = (ocScript: ScriptFile): BrunoItem => {
+  const brunoItem: BrunoItem = {
+    uid: uuid(),
+    type: 'js',
+    seq: 1,
+    name: 'Script',
+    tags: [],
+    request: null,
+    settings: null,
+    fileContent: ocScript.script || '',
+    root: null,
+    items: [],
+    examples: [],
+    filename: null,
+    pathname: null
+  };
+
+  return brunoItem;
+};
+
+export default parseScript;

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

@@ -0,0 +1,106 @@
+import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
+import type { WebSocketRequest as BrunoWebSocketRequest } from '@usebruno/schema-types/requests/websocket';
+import type { WebSocketRequest, WebSocketMessage } from '@opencollection/types/requests/websocket';
+import { toBrunoAuth } from '../common/auth';
+import { toBrunoHttpHeaders } from '../common/headers';
+import { toBrunoVariables } from '../common/variables';
+import { toBrunoScripts } from '../common/scripts';
+import { uuid } from '../../../utils';
+
+const parseWebsocketRequest = (ocRequest: WebSocketRequest): BrunoItem => {
+  const info = ocRequest.info;
+  const websocket = ocRequest.websocket;
+  const runtime = ocRequest.runtime;
+
+  const brunoRequest: BrunoWebSocketRequest = {
+    url: websocket?.url || '',
+    headers: toBrunoHttpHeaders(websocket?.headers) || [],
+    auth: toBrunoAuth(websocket?.auth),
+    body: {
+      mode: 'ws',
+      ws: []
+    },
+    script: {
+      req: null,
+      res: null
+    },
+    vars: {
+      req: [],
+      res: []
+    },
+    assertions: [],
+    tests: null,
+    docs: null
+  };
+
+  // message
+  if (websocket?.message) {
+    const message = websocket.message as WebSocketMessage;
+    if (message.data?.trim().length) {
+      brunoRequest.body.ws = [{
+        name: '',
+        type: message.type || 'text',
+        content: message.data
+      }];
+    }
+  }
+
+  // scripts
+  const scripts = toBrunoScripts(runtime?.scripts);
+  if (scripts?.script && brunoRequest.script) {
+    if (scripts.script.req) {
+      brunoRequest.script.req = scripts.script.req;
+    }
+    if (scripts.script.res) {
+      brunoRequest.script.res = scripts.script.res;
+    }
+  }
+  if (scripts?.tests) {
+    brunoRequest.tests = scripts.tests;
+  }
+
+  // variables
+  const variables = toBrunoVariables(runtime?.variables);
+  brunoRequest.vars = variables;
+
+  // docs
+  if (ocRequest.docs) {
+    brunoRequest.docs = ocRequest.docs;
+  }
+
+  // settings
+  const wsSettings: Record<string, number> = {
+    timeout: 0,
+    keepAliveInterval: 0
+  };
+
+  if (ocRequest.settings) {
+    if (typeof ocRequest.settings.timeout === 'number') {
+      wsSettings.timeout = ocRequest.settings.timeout;
+    }
+    if (typeof ocRequest.settings.keepAliveInterval === 'number') {
+      wsSettings.keepAliveInterval = ocRequest.settings.keepAliveInterval;
+    }
+  }
+
+  // bruno item
+  const brunoItem: BrunoItem = {
+    uid: uuid(),
+    type: 'ws-request',
+    seq: info?.seq || 1,
+    name: info?.name || 'Untitled Request',
+    tags: info?.tags || [],
+    request: brunoRequest,
+    settings: wsSettings as any,
+    fileContent: null,
+    root: null,
+    items: [],
+    examples: [],
+    filename: null,
+    pathname: null
+  };
+
+  return brunoItem;
+};
+
+export default parseWebsocketRequest;