@usebruno/filestore 0.4.0 → 0.6.0

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

@@ -0,0 +1,168 @@
+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, GraphQLRequestInfo, GraphQLRequestDetails, GraphQLRequestRuntime } from '@opencollection/types/requests/graphql';
+import type { Auth } from '@opencollection/types/common/auth';
+import type { Scripts } from '@opencollection/types/common/scripts';
+import type { Variable } from '@opencollection/types/common/variables';
+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 { toOpenCollectionAuth } from '../common/auth';
+import { toOpenCollectionHttpHeaders } from '../common/headers';
+import { toOpenCollectionParams } from '../common/params';
+import { toOpenCollectionVariables } from '../common/variables';
+import { toOpenCollectionActions } from '../common/actions';
+import { toOpenCollectionScripts } from '../common/scripts';
+import { toOpenCollectionAssertions } from '../common/assertions';
+
+const stringifyGraphQLRequest = (item: BrunoItem): string => {
+  try {
+    const ocRequest: GraphQLRequest = {};
+    const brunoRequest = item.request as BrunoHttpRequest;
+
+    // info block
+    const info: GraphQLRequestInfo = {
+      name: isNonEmptyString(item.name) ? item.name : 'Untitled Request',
+      type: 'graphql'
+    };
+    if (item.seq) {
+      info.seq = item.seq;
+    }
+    if (item.tags?.length) {
+      info.tags = item.tags;
+    }
+    ocRequest.info = info;
+
+    // graphql block
+    const graphql: GraphQLRequestDetails = {
+      method: isNonEmptyString(brunoRequest.method) ? brunoRequest.method : 'POST',
+      url: isNonEmptyString(brunoRequest.url) ? brunoRequest.url : ''
+    };
+
+    // headers
+    const headers: HttpRequestHeader[] | undefined = toOpenCollectionHttpHeaders(brunoRequest.headers);
+    if (headers) {
+      graphql.headers = headers;
+    }
+
+    // params
+    const params: HttpRequestParam[] | undefined = toOpenCollectionParams(brunoRequest.params);
+    if (params) {
+      graphql.params = params;
+    }
+
+    // body
+    if (brunoRequest.body?.mode === 'graphql' && brunoRequest.body.graphql) {
+      const graphqlBody: GraphQLBody = {};
+      let hasBody = false;
+
+      if (isNonEmptyString(brunoRequest.body.graphql.query)) {
+        graphqlBody.query = brunoRequest.body.graphql.query;
+        hasBody = true;
+      }
+
+      if (isNonEmptyString(brunoRequest.body.graphql.variables)) {
+        graphqlBody.variables = brunoRequest.body.graphql.variables;
+        hasBody = true;
+      }
+
+      if (hasBody) {
+        graphql.body = graphqlBody;
+      }
+    }
+
+    // auth (in graphql block, not runtime)
+    const auth: Auth | undefined = toOpenCollectionAuth(brunoRequest.auth);
+    if (auth) {
+      graphql.auth = auth;
+    }
+
+    ocRequest.graphql = graphql;
+
+    // runtime block
+    const runtime: GraphQLRequestRuntime = {};
+    let hasRuntime = false;
+
+    // variables
+    const variables: Variable[] | undefined = toOpenCollectionVariables(brunoRequest.vars);
+    if (variables) {
+      runtime.variables = variables;
+      hasRuntime = true;
+    }
+
+    // scripts
+    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest);
+    if (scripts) {
+      runtime.scripts = scripts;
+      hasRuntime = true;
+    }
+
+    // assertions
+    const assertions: Assertion[] | undefined = toOpenCollectionAssertions(brunoRequest.assertions);
+    if (assertions) {
+      runtime.assertions = assertions;
+      hasRuntime = true;
+    }
+
+    // actions (from post-response variables)
+    const resVars = brunoRequest.vars?.res;
+    const actions: Action[] | undefined = toOpenCollectionActions(resVars);
+    if (actions) {
+      runtime.actions = actions;
+      hasRuntime = true;
+    }
+
+    if (hasRuntime) {
+      ocRequest.runtime = runtime;
+    }
+
+    // settings
+    const httpSettings = item.settings as BrunoHttpItemSettings | undefined;
+    const settings: GraphQLRequestSettings = {};
+    if (httpSettings?.encodeUrl === true) {
+      settings.encodeUrl = true;
+    } else if (httpSettings?.encodeUrl === false) {
+      settings.encodeUrl = false;
+    } else {
+      settings.encodeUrl = true;
+    }
+
+    const timeout = httpSettings?.timeout;
+    if (isNumber(timeout)) {
+      settings.timeout = timeout;
+    } else {
+      settings.timeout = 0;
+    }
+
+    if (httpSettings?.followRedirects === true) {
+      settings.followRedirects = true;
+    } else if (httpSettings?.followRedirects === false) {
+      settings.followRedirects = false;
+    } else {
+      settings.followRedirects = true;
+    }
+
+    const maxRedirects = httpSettings?.maxRedirects;
+    if (isNumber(maxRedirects)) {
+      settings.maxRedirects = maxRedirects;
+    } else {
+      settings.maxRedirects = 5;
+    }
+
+    ocRequest.settings = settings;
+
+    // docs
+    if (isNonEmptyString(brunoRequest.docs)) {
+      ocRequest.docs = brunoRequest.docs;
+    }
+
+    return stringifyYml(ocRequest);
+  } catch (error) {
+    console.error('Error stringifying GraphQL request:', error);
+    throw error;
+  }
+};
+
+export default stringifyGraphQLRequest;

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

@@ -0,0 +1,137 @@
+import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
+import type { KeyValue as BrunoKeyValue } from '@usebruno/schema-types/common/key-value';
+import type { GrpcRequest as BrunoGrpcRequest } from '@usebruno/schema-types/requests/grpc';
+import type { GrpcRequest, GrpcMetadata, GrpcMessage, GrpcRequestInfo, GrpcRequestDetails, GrpcRequestRuntime } from '@opencollection/types/requests/grpc';
+import type { Auth } from '@opencollection/types/common/auth';
+import type { Scripts } from '@opencollection/types/common/scripts';
+import type { Variable } from '@opencollection/types/common/variables';
+import type { Assertion } from '@opencollection/types/common/assertions';
+import { stringifyYml } from '../utils';
+import { isNonEmptyString } from '../../../utils';
+import { toOpenCollectionAuth } from '../common/auth';
+import { toOpenCollectionVariables } from '../common/variables';
+import { toOpenCollectionScripts } from '../common/scripts';
+import { toOpenCollectionAssertions } from '../common/assertions';
+
+const stringifyGrpcRequest = (item: BrunoItem): string => {
+  try {
+    const ocRequest: GrpcRequest = {};
+    const brunoRequest = item.request as BrunoGrpcRequest;
+
+    // info block
+    const info: GrpcRequestInfo = {
+      name: isNonEmptyString(item.name) ? item.name : 'Untitled Request',
+      type: 'grpc'
+    };
+    if (item.seq) {
+      info.seq = item.seq;
+    }
+    if (item.tags?.length) {
+      info.tags = item.tags;
+    }
+    ocRequest.info = info;
+
+    // grpc block
+    const grpc: GrpcRequestDetails = {
+      url: isNonEmptyString(brunoRequest.url) ? brunoRequest.url : '',
+      method: isNonEmptyString(brunoRequest.method) ? brunoRequest.method : ''
+    };
+
+    // method type
+    if (brunoRequest.methodType) {
+      grpc.methodType = brunoRequest.methodType;
+    }
+
+    // proto file path
+    if (isNonEmptyString(brunoRequest.protoPath)) {
+      grpc.protoFilePath = brunoRequest.protoPath;
+    }
+
+    // metadata
+    if (brunoRequest.headers?.length) {
+      const metadata: GrpcMetadata[] = brunoRequest.headers.map((header: BrunoKeyValue) => {
+        const metadataItem: GrpcMetadata = {
+          name: header.name || '',
+          value: header.value || ''
+        };
+
+        if (header?.description?.trim().length) {
+          metadataItem.description = header.description;
+        }
+
+        if (header.enabled === false) {
+          metadataItem.disabled = true;
+        }
+
+        return metadataItem;
+      });
+
+      if (metadata.length) {
+        grpc.metadata = metadata;
+      }
+    }
+
+    // message
+    if (brunoRequest.body?.mode === 'grpc' && brunoRequest.body.grpc?.length) {
+      const messages = brunoRequest.body.grpc;
+
+      // todo: bruno app supports only one message for now
+      // update this when bruno app supports multiple messages
+      if (messages.length) {
+        const message: GrpcMessage = messages[0].content || '';
+        if (message.trim().length) {
+          grpc.message = message;
+        }
+      }
+    }
+
+    // auth
+    const auth: Auth | undefined = toOpenCollectionAuth(brunoRequest.auth);
+    if (auth) {
+      grpc.auth = auth;
+    }
+
+    ocRequest.grpc = grpc;
+
+    // runtime block
+    const runtime: GrpcRequestRuntime = {};
+    let hasRuntime = false;
+
+    // variables
+    const variables: Variable[] | undefined = toOpenCollectionVariables(brunoRequest.vars);
+    if (variables) {
+      runtime.variables = variables;
+      hasRuntime = true;
+    }
+
+    // scripts
+    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest);
+    if (scripts) {
+      runtime.scripts = scripts;
+      hasRuntime = true;
+    }
+
+    // assertions
+    const assertions: Assertion[] | undefined = toOpenCollectionAssertions(brunoRequest.assertions);
+    if (assertions) {
+      runtime.assertions = assertions;
+      hasRuntime = true;
+    }
+
+    if (hasRuntime) {
+      ocRequest.runtime = runtime;
+    }
+
+    // docs
+    if (isNonEmptyString(brunoRequest.docs)) {
+      ocRequest.docs = brunoRequest.docs;
+    }
+
+    return stringifyYml(ocRequest);
+  } catch (error) {
+    console.error('Error stringifying gRPC request:', error);
+    throw error;
+  }
+};
+
+export default stringifyGrpcRequest;

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

@@ -0,0 +1,221 @@
+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, HttpRequestSettings, HttpRequestExample, HttpRequestInfo, HttpRequestDetails, HttpRequestRuntime, HttpRequestHeader } from '@opencollection/types/requests/http';
+import type { Auth } from '@opencollection/types/common/auth';
+import type { Scripts } from '@opencollection/types/common/scripts';
+import type { Variable } from '@opencollection/types/common/variables';
+import type { Assertion } from '@opencollection/types/common/assertions';
+import type { Action } from '@opencollection/types/common/actions';
+import type { HttpRequestParam, HttpRequestBody } from '@opencollection/types/requests/http';
+import { stringifyYml } from '../utils';
+import { toOpenCollectionAuth } from '../common/auth';
+import { toOpenCollectionHttpHeaders, toOpenCollectionResponseHeaders } from '../common/headers';
+import { toOpenCollectionParams } from '../common/params';
+import { toOpenCollectionBody } from '../common/body';
+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';
+
+const stringifyHttpRequest = (item: BrunoItem): string => {
+  try {
+    const ocRequest: HttpRequest = {};
+    const brunoRequest = item.request as BrunoHttpRequest;
+
+    // info block
+    const info: HttpRequestInfo = {
+      name: isNonEmptyString(item.name) ? item.name : 'Untitled Request',
+      type: 'http'
+    };
+    if (item.seq) {
+      info.seq = item.seq;
+    }
+    if (item.tags?.length) {
+      info.tags = item.tags;
+    }
+    ocRequest.info = info;
+
+    // http block
+    const http: HttpRequestDetails = {
+      method: isNonEmptyString(brunoRequest.method) ? brunoRequest.method : 'GET',
+      url: isNonEmptyString(brunoRequest.url) ? brunoRequest.url : ''
+    };
+
+    // headers
+    const headers: HttpRequestHeader[] | undefined = toOpenCollectionHttpHeaders(brunoRequest.headers);
+    if (headers) {
+      http.headers = headers;
+    }
+
+    // params
+    const params: HttpRequestParam[] | undefined = toOpenCollectionParams(brunoRequest.params);
+    if (params) {
+      http.params = params;
+    }
+
+    // body
+    const body: HttpRequestBody | undefined = toOpenCollectionBody(brunoRequest.body);
+    if (body) {
+      http.body = body;
+    }
+
+    // auth
+    const auth: Auth | undefined = toOpenCollectionAuth(brunoRequest.auth);
+    if (auth) {
+      http.auth = auth;
+    }
+
+    ocRequest.http = http;
+
+    // runtime block
+    const runtime: HttpRequestRuntime = {};
+    let hasRuntime = false;
+
+    // variables
+    const variables: Variable[] | undefined = toOpenCollectionVariables(brunoRequest.vars);
+    if (variables) {
+      runtime.variables = variables;
+      hasRuntime = true;
+    }
+
+    // scripts
+    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest);
+    if (scripts) {
+      runtime.scripts = scripts;
+      hasRuntime = true;
+    }
+
+    // assertions
+    const assertions: Assertion[] | undefined = toOpenCollectionAssertions(brunoRequest.assertions);
+    if (assertions) {
+      runtime.assertions = assertions;
+      hasRuntime = true;
+    }
+
+    // actions (from post-response variables)
+    const resVars = brunoRequest.vars?.res;
+    const actions: Action[] | undefined = toOpenCollectionActions(resVars);
+    if (actions) {
+      runtime.actions = actions;
+      hasRuntime = true;
+    }
+
+    if (hasRuntime) {
+      ocRequest.runtime = runtime;
+    }
+
+    // settings
+    const httpSettings = item.settings as BrunoHttpItemSettings | undefined;
+    const settings: HttpRequestSettings = {};
+    if (httpSettings?.encodeUrl === true) {
+      settings.encodeUrl = true;
+    } else if (httpSettings?.encodeUrl === false) {
+      settings.encodeUrl = false;
+    } else {
+      settings.encodeUrl = true;
+    }
+
+    const timeout = httpSettings?.timeout;
+    if (isNumber(timeout)) {
+      settings.timeout = timeout;
+    } else {
+      settings.timeout = 0;
+    }
+
+    if (httpSettings?.followRedirects === true) {
+      settings.followRedirects = true;
+    } else if (httpSettings?.followRedirects === false) {
+      settings.followRedirects = false;
+    } else {
+      settings.followRedirects = true;
+    }
+
+    const maxRedirects = httpSettings?.maxRedirects;
+    if (isNumber(maxRedirects)) {
+      settings.maxRedirects = maxRedirects;
+    } else {
+      settings.maxRedirects = 5;
+    }
+
+    ocRequest.settings = settings;
+
+    // examples
+    if (item.examples?.length) {
+      const examples: HttpRequestExample[] = item.examples.map((example) => {
+        const ocExample: HttpRequestExample = {};
+        ocExample.name = example?.name || 'Untitled Example';
+
+        if (isNonEmptyString(example.description)) {
+          ocExample.description = example.description;
+        }
+
+        if (example.request) {
+          ocExample.request = {};
+          ocExample.request.url = example.request.url || '';
+          ocExample.request.method = example.request.method || 'GET';
+
+          const exampleHeaders = toOpenCollectionHttpHeaders(example.request.headers);
+          if (exampleHeaders) {
+            ocExample.request.headers = exampleHeaders;
+          }
+
+          const exampleParams = toOpenCollectionParams(example.request.params);
+          if (exampleParams) {
+            ocExample.request.params = exampleParams;
+          }
+
+          const exampleBody = toOpenCollectionBody(example.request.body);
+          if (exampleBody !== undefined) {
+            ocExample.request.body = exampleBody;
+          }
+        }
+
+        if (example.response) {
+          ocExample.response = {};
+
+          if (example.response.status !== undefined && example.response.status !== null && isNumber(example.response.status)) {
+            ocExample.response.status = Number(example.response.status);
+          }
+
+          if (isNonEmptyString(example.response.statusText)) {
+            ocExample.response.statusText = example.response.statusText;
+          }
+
+          const responseHeaders = toOpenCollectionResponseHeaders(example.response.headers);
+          if (responseHeaders) {
+            ocExample.response.headers = responseHeaders;
+          }
+
+          if (example.response.body && example.response.body.type && example.response.body.content !== undefined) {
+            const content = example.response.body.content;
+            const contentString = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+
+            ocExample.response.body = {
+              type: example.response.body.type as 'json' | 'text' | 'xml' | 'html' | 'binary',
+              data: contentString
+            };
+          }
+        }
+
+        return ocExample;
+      });
+
+      if (examples?.length) {
+        ocRequest.examples = examples;
+      }
+    }
+
+    // docs
+    if (isNonEmptyString(brunoRequest.docs)) {
+      ocRequest.docs = brunoRequest.docs;
+    }
+
+    return stringifyYml(ocRequest);
+  } catch (error) {
+    console.error('Error stringifying HTTP request:', error);
+    throw error;
+  }
+};
+
+export default stringifyHttpRequest;

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

@@ -0,0 +1,22 @@
+import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
+import type { ScriptFile } from '@opencollection/types/collection/item';
+import { stringifyYml } from '../utils';
+
+const stringifyScript = (item: BrunoItem): string => {
+  try {
+    const ocScript: ScriptFile = {
+      type: 'script'
+    };
+
+    if (item.fileContent?.trim().length) {
+      ocScript.script = item.fileContent;
+    }
+
+    return stringifyYml(ocScript);
+  } catch (error) {
+    console.error('Error stringifying script:', error);
+    throw error;
+  }
+};
+
+export default stringifyScript;

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

@@ -0,0 +1,114 @@
+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, WebSocketRequestInfo, WebSocketRequestDetails, WebSocketRequestRuntime } from '@opencollection/types/requests/websocket';
+import type { Auth } from '@opencollection/types/common/auth';
+import type { Scripts } from '@opencollection/types/common/scripts';
+import type { Variable } from '@opencollection/types/common/variables';
+import type { HttpRequestHeader } from '@opencollection/types/requests/http';
+import { stringifyYml } from '../utils';
+import { isNonEmptyString } from '../../../utils';
+import { toOpenCollectionAuth } from '../common/auth';
+import { toOpenCollectionHttpHeaders } from '../common/headers';
+import { toOpenCollectionVariables } from '../common/variables';
+import { toOpenCollectionScripts } from '../common/scripts';
+
+const stringifyWebsocketRequest = (item: BrunoItem): string => {
+  try {
+    const ocRequest: WebSocketRequest = {};
+    const brunoRequest = item.request as BrunoWebSocketRequest;
+
+    // info block
+    const info: WebSocketRequestInfo = {
+      name: isNonEmptyString(item.name) ? item.name : 'Untitled Request',
+      type: 'websocket'
+    };
+    if (item.seq) {
+      info.seq = item.seq;
+    }
+    if (item.tags?.length) {
+      info.tags = item.tags;
+    }
+    ocRequest.info = info;
+
+    // websocket block
+    const websocket: WebSocketRequestDetails = {
+      url: isNonEmptyString(brunoRequest.url) ? brunoRequest.url : ''
+    };
+
+    // headers
+    const headers: HttpRequestHeader[] | undefined = toOpenCollectionHttpHeaders(brunoRequest.headers);
+    if (headers) {
+      websocket.headers = headers;
+    }
+
+    // message
+    if (brunoRequest.body?.mode === 'ws' && brunoRequest.body.ws?.length) {
+      const messages = brunoRequest.body.ws;
+
+      // todo: bruno app supports only one message for now
+      // update this when bruno app supports multiple messages
+      if (messages.length) {
+        const msg = messages[0];
+        const message: WebSocketMessage = {
+          type: (msg.type as 'text' | 'json' | 'xml' | 'binary') || 'text',
+          data: msg.content || ''
+        };
+        if (message.data.trim().length) {
+          websocket.message = message;
+        }
+      }
+    }
+
+    // auth
+    const auth: Auth | undefined = toOpenCollectionAuth(brunoRequest.auth);
+    if (auth) {
+      websocket.auth = auth;
+    }
+
+    ocRequest.websocket = websocket;
+
+    // runtime block
+    const runtime: WebSocketRequestRuntime = {};
+    let hasRuntime = false;
+
+    // variables
+    const variables: Variable[] | undefined = toOpenCollectionVariables(brunoRequest.vars);
+    if (variables) {
+      runtime.variables = variables;
+      hasRuntime = true;
+    }
+
+    // scripts
+    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest);
+    if (scripts) {
+      runtime.scripts = scripts;
+      hasRuntime = true;
+    }
+
+    if (hasRuntime) {
+      ocRequest.runtime = runtime;
+    }
+
+    // settings
+    const wsSettings = item.settings as Record<string, number | string | undefined> | undefined;
+    if (wsSettings) {
+      ocRequest.settings = {};
+      const timeout = Number(wsSettings.timeout);
+      ocRequest.settings.timeout = !isNaN(timeout) ? timeout : 0;
+      const keepAliveInterval = Number(wsSettings.keepAliveInterval);
+      ocRequest.settings.keepAliveInterval = !isNaN(keepAliveInterval) ? keepAliveInterval : 0;
+    }
+
+    // docs
+    if (isNonEmptyString(brunoRequest.docs)) {
+      ocRequest.docs = brunoRequest.docs;
+    }
+
+    return stringifyYml(ocRequest);
+  } catch (error) {
+    console.error('Error stringifying WebSocket request:', error);
+    throw error;
+  }
+};
+
+export default stringifyWebsocketRequest;