@usebruno/filestore 0.4.0 → 0.6.0

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

@@ -0,0 +1,245 @@
+import type {
+  Auth,
+  AuthApiKey,
+  AuthAwsV4,
+  AuthBasic,
+  AuthBearer,
+  AuthDigest,
+  AuthNTLM,
+  AuthWsse
+} from '@opencollection/types/common/auth';
+import type { Auth as BrunoAuth } from '@usebruno/schema-types/common/auth';
+import { isString } from '../../../utils';
+import { toOpenCollectionOAuth2, toBrunoOAuth2 } from './auth-oauth2';
+
+const buildAwsV4Auth = (config?: BrunoAuth['awsv4']): AuthAwsV4 => {
+  const auth: AuthAwsV4 = { type: 'awsv4' };
+
+  if (!config) {
+    return auth;
+  }
+
+  if (isString(config.accessKeyId)) auth.accessKeyId = config.accessKeyId;
+  if (isString(config.secretAccessKey)) auth.secretAccessKey = config.secretAccessKey;
+  if (isString(config.sessionToken)) auth.sessionToken = config.sessionToken;
+  if (isString(config.service)) auth.service = config.service;
+  if (isString(config.region)) auth.region = config.region;
+  if (isString(config.profileName)) auth.profileName = config.profileName;
+
+  return auth;
+};
+
+const buildBasicAuth = (config?: BrunoAuth['basic']): AuthBasic => {
+  const auth: AuthBasic = { type: 'basic' };
+
+  if (!config) {
+    return auth;
+  }
+
+  if (isString(config.username)) auth.username = config.username;
+  if (isString(config.password)) auth.password = config.password;
+
+  return auth;
+};
+
+const buildBearerAuth = (config?: BrunoAuth['bearer']): AuthBearer => {
+  const auth: AuthBearer = { type: 'bearer' };
+
+  if (!config) {
+    return auth;
+  }
+
+  if (isString(config.token)) auth.token = config.token;
+
+  return auth;
+};
+
+const buildDigestAuth = (config?: BrunoAuth['digest']): AuthDigest => {
+  const auth: AuthDigest = { type: 'digest' };
+
+  if (!config) {
+    return auth;
+  }
+
+  if (isString(config.username)) auth.username = config.username;
+  if (isString(config.password)) auth.password = config.password;
+
+  return auth;
+};
+
+const buildNtlmAuth = (config?: BrunoAuth['ntlm']): AuthNTLM => {
+  const auth: AuthNTLM = { type: 'ntlm' };
+
+  if (!config) {
+    return auth;
+  }
+
+  if (isString(config.username)) auth.username = config.username;
+  if (isString(config.password)) auth.password = config.password;
+  if (isString(config.domain)) auth.domain = config.domain;
+
+  return auth;
+};
+
+const buildWsseAuth = (config?: BrunoAuth['wsse']): AuthWsse => {
+  const auth: AuthWsse = { type: 'wsse' };
+
+  if (!config) {
+    return auth;
+  }
+
+  if (isString(config.username)) auth.username = config.username;
+  if (isString(config.password)) auth.password = config.password;
+
+  return auth;
+};
+
+const buildApiKeyAuth = (config?: BrunoAuth['apikey']): AuthApiKey => {
+  const auth: AuthApiKey = { type: 'apikey' };
+
+  if (!config) {
+    return auth;
+  }
+
+  if (isString(config.key)) auth.key = config.key;
+  if (isString(config.value)) auth.value = config.value;
+
+  if (isString(config.placement)) {
+    if (config.placement === 'header') {
+      auth.placement = 'header';
+    } else if (config.placement === 'queryparams') {
+      auth.placement = 'query';
+    }
+  }
+
+  return auth;
+};
+
+export const toOpenCollectionAuth = (auth?: BrunoAuth | null): Auth | undefined => {
+  if (!auth || auth.mode === 'none') {
+    return undefined;
+  }
+
+  if (auth.mode === 'inherit') {
+    return 'inherit';
+  }
+
+  switch (auth.mode) {
+    case 'awsv4':
+      return buildAwsV4Auth(auth.awsv4);
+    case 'basic':
+      return buildBasicAuth(auth.basic);
+    case 'bearer':
+      return buildBearerAuth(auth.bearer);
+    case 'digest':
+      return buildDigestAuth(auth.digest);
+    case 'ntlm':
+      return buildNtlmAuth(auth.ntlm);
+    case 'wsse':
+      return buildWsseAuth(auth.wsse);
+    case 'apikey':
+      return buildApiKeyAuth(auth.apikey);
+    case 'oauth2':
+      return toOpenCollectionOAuth2(auth.oauth2);
+    default:
+      console.warn(`toOpenCollectionAuth failed: Unsupported auth mode "${auth.mode}".`);
+      return undefined;
+  }
+};
+
+export const toBrunoAuth = (auth: Auth | null | undefined): BrunoAuth | null => {
+  const brunoAuth: BrunoAuth = {
+    mode: 'none',
+    awsv4: null,
+    basic: null,
+    bearer: null,
+    digest: null,
+    ntlm: null,
+    oauth2: null,
+    wsse: null,
+    apikey: null
+  };
+
+  if (!auth) {
+    return brunoAuth;
+  }
+
+  if (auth === 'inherit') {
+    brunoAuth.mode = 'inherit';
+    return brunoAuth;
+  }
+
+  switch (auth.type) {
+    case 'awsv4':
+      brunoAuth.mode = 'awsv4';
+      brunoAuth.awsv4 = {
+        accessKeyId: auth.accessKeyId || null,
+        secretAccessKey: auth.secretAccessKey || null,
+        sessionToken: auth.sessionToken || null,
+        service: auth.service || null,
+        region: auth.region || null,
+        profileName: auth.profileName || null
+      };
+      break;
+
+    case 'basic':
+      brunoAuth.mode = 'basic';
+      brunoAuth.basic = {
+        username: auth.username || null,
+        password: auth.password || null
+      };
+      break;
+
+    case 'bearer':
+      brunoAuth.mode = 'bearer';
+      brunoAuth.bearer = {
+        token: auth.token || ''
+      };
+      break;
+
+    case 'digest':
+      brunoAuth.mode = 'digest';
+      brunoAuth.digest = {
+        username: auth.username || null,
+        password: auth.password || null
+      };
+      break;
+
+    case 'ntlm':
+      brunoAuth.mode = 'ntlm';
+      brunoAuth.ntlm = {
+        username: auth.username || null,
+        password: auth.password || null,
+        domain: auth.domain || null
+      };
+      break;
+
+    case 'wsse':
+      brunoAuth.mode = 'wsse';
+      brunoAuth.wsse = {
+        username: auth.username || null,
+        password: auth.password || null
+      };
+      break;
+
+    case 'apikey':
+      brunoAuth.mode = 'apikey';
+      brunoAuth.apikey = {
+        key: auth.key || null,
+        value: auth.value || null,
+        placement: auth.placement === 'query' ? 'queryparams' : (auth.placement === 'header' ? 'header' : null)
+      };
+      break;
+
+    case 'oauth2':
+      brunoAuth.mode = 'oauth2';
+      brunoAuth.oauth2 = toBrunoOAuth2(auth);
+      break;
+
+    default:
+      console.warn('toBrunoAuth failed: Unsupported auth type');
+      break;
+  }
+
+  return brunoAuth;
+};

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

@@ -0,0 +1,238 @@
+import type { HttpRequestBody as BrunoHttpRequestBody } from '@usebruno/schema-types/requests/http';
+import type {
+  HttpRequestBody,
+  RawBody,
+  FormUrlEncodedBody,
+  FormUrlEncodedEntry,
+  MultipartFormBody,
+  MultipartFormEntry,
+  FileBody,
+  FileBodyEntry
+} from '@opencollection/types/requests/http';
+import type { KeyValue as BrunoKeyValue } from '@usebruno/schema-types/common/key-value';
+import { uuid } from '../../../utils';
+
+export const toOpenCollectionBody = (body: BrunoHttpRequestBody | null | undefined): HttpRequestBody | undefined => {
+  if (!body) {
+    return undefined;
+  }
+
+  switch (body.mode) {
+    case 'none':
+      return undefined;
+
+    case 'json':
+      const rawBody: RawBody = {
+        type: 'json',
+        data: body.json || ''
+      };
+      return rawBody;
+
+    case 'text':
+      const textBody: RawBody = {
+        type: 'text',
+        data: body.text || ''
+      };
+      return textBody;
+
+    case 'xml':
+      const xmlBody: RawBody = {
+        type: 'xml',
+        data: body.xml || ''
+      };
+      return xmlBody;
+
+    case 'sparql':
+      const sparqlBody: RawBody = {
+        type: 'sparql',
+        data: body.sparql || ''
+      };
+      return sparqlBody;
+
+    case 'formUrlEncoded':
+      const formEntries: FormUrlEncodedEntry[] = body.formUrlEncoded?.map((entry: BrunoKeyValue): FormUrlEncodedEntry => {
+        const formEntry: FormUrlEncodedEntry = {
+          name: entry.name || '',
+          value: entry.value || ''
+        };
+
+        if (entry?.description?.trim().length) {
+          formEntry.description = entry.description;
+        }
+
+        if (entry.enabled === false) {
+          formEntry.disabled = true;
+        }
+
+        return formEntry;
+      }) || [];
+
+      const formBody: FormUrlEncodedBody = {
+        type: 'form-urlencoded',
+        ...(formEntries.length > 0 && { data: formEntries })
+      } as FormUrlEncodedBody;
+      return formBody;
+
+    case 'multipartForm':
+      const multipartEntries: MultipartFormEntry[] = body.multipartForm?.map((entry): MultipartFormEntry => {
+        const multipartEntry: MultipartFormEntry = {
+          name: entry.name || '',
+          type: entry.type,
+          value: entry.value || (entry.type === 'file' ? [] : '')
+        };
+
+        if (entry?.contentType?.trim().length) {
+          multipartEntry.contentType = entry.contentType;
+        }
+
+        if (entry?.description?.trim().length) {
+          multipartEntry.description = entry.description;
+        }
+
+        if (entry.enabled === false) {
+          multipartEntry.disabled = true;
+        }
+
+        return multipartEntry;
+      }) || [];
+
+      const multipartBody: MultipartFormBody = {
+        type: 'multipart-form',
+        ...(multipartEntries.length > 0 && { data: multipartEntries })
+      } as MultipartFormBody;
+      return multipartBody;
+
+    case 'file':
+      const fileEntries: FileBodyEntry[] = body.file?.map((file): FileBodyEntry => {
+        return {
+          filePath: file.filePath || '',
+          contentType: file.contentType || '',
+          selected: file.selected ?? false
+        };
+      }) || [];
+
+      const fileBody: FileBody = {
+        type: 'file',
+        ...(fileEntries.length > 0 && { data: fileEntries })
+      } as FileBody;
+      return fileBody;
+
+    case 'graphql':
+      // GraphQL body is handled separately in GraphQL request stringify
+      return undefined;
+
+    default:
+      return undefined;
+  }
+};
+
+export const toBrunoBody = (body: HttpRequestBody | null | undefined): BrunoHttpRequestBody | undefined => {
+  if (!body) {
+    return {
+      mode: 'none',
+      json: null,
+      text: null,
+      xml: null,
+      sparql: null,
+      formUrlEncoded: [],
+      multipartForm: [],
+      graphql: null,
+      file: []
+    };
+  }
+
+  const brunoBody: BrunoHttpRequestBody = {
+    mode: 'none',
+    json: null,
+    text: null,
+    xml: null,
+    sparql: null,
+    formUrlEncoded: [],
+    multipartForm: [],
+    graphql: null,
+    file: []
+  };
+
+  switch (body.type) {
+    case 'json':
+      brunoBody.mode = 'json';
+      brunoBody.json = body.data || '';
+      break;
+
+    case 'text':
+      brunoBody.mode = 'text';
+      brunoBody.text = body.data || '';
+      break;
+
+    case 'xml':
+      brunoBody.mode = 'xml';
+      brunoBody.xml = body.data || '';
+      break;
+
+    case 'sparql':
+      brunoBody.mode = 'sparql';
+      brunoBody.sparql = body.data || '';
+      break;
+
+    case 'form-urlencoded':
+      brunoBody.mode = 'formUrlEncoded';
+      brunoBody.formUrlEncoded = body.data?.map((entry): BrunoKeyValue => {
+        const formEntry: BrunoKeyValue = {
+          uid: uuid(),
+          name: entry.name || '',
+          value: entry.value || '',
+          enabled: entry.disabled !== true
+        };
+
+        if (entry.description) {
+          if (typeof entry.description === 'string' && entry.description.trim().length) {
+            formEntry.description = entry.description;
+          } else if (typeof entry.description === 'object' && entry.description.content?.trim().length) {
+            formEntry.description = entry.description.content;
+          }
+        }
+
+        return formEntry;
+      }) || [];
+      break;
+
+    case 'multipart-form':
+      brunoBody.mode = 'multipartForm';
+      brunoBody.multipartForm = body.data?.map((entry): any => {
+        const multipartEntry: any = {
+          uid: uuid(),
+          type: entry.type,
+          name: entry.name || '',
+          value: entry.value || (entry.type === 'file' ? [] : ''),
+          contentType: entry.contentType || null,
+          enabled: entry.disabled !== true
+        };
+
+        if (entry.description) {
+          if (typeof entry.description === 'string' && entry.description.trim().length) {
+            multipartEntry.description = entry.description;
+          } else if (typeof entry.description === 'object' && entry.description.content?.trim().length) {
+            multipartEntry.description = entry.description.content;
+          }
+        }
+
+        return multipartEntry;
+      }) || [];
+      break;
+
+    case 'file':
+      brunoBody.mode = 'file';
+      brunoBody.file = body.data?.map((file): any => ({
+        uid: uuid(),
+        filePath: file.filePath || '',
+        contentType: file.contentType || '',
+        selected: file.selected ?? false
+      })) || [];
+      break;
+
+    default:
+      break;
+  }
+
+  return brunoBody;
+};

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

@@ -0,0 +1,58 @@
+import type { FolderRequest as BrunoFolderRequest } from '@usebruno/schema-types/collection/folder';
+import type { KeyValue as BrunoKeyValue } from '@usebruno/schema-types/common/key-value';
+import type { HttpRequestHeader, HttpResponseHeader } from '@opencollection/types/requests/http';
+import { uuid } from '../../../utils';
+
+export const toOpenCollectionHttpHeaders = (headers: BrunoFolderRequest['headers']): HttpRequestHeader[] | undefined => {
+  if (!headers?.length) {
+    return undefined;
+  }
+
+  const ocHeaders = headers.map((header: BrunoKeyValue): HttpRequestHeader => {
+    const httpHeader: HttpRequestHeader = {
+      name: header.name || '',
+      value: header.value || ''
+    };
+    if (header?.description?.trim().length) {
+      httpHeader.description = header.description;
+    }
+    if (header.enabled === false) {
+      httpHeader.disabled = true;
+    }
+    return httpHeader;
+  });
+
+  return ocHeaders.length ? ocHeaders : undefined;
+};
+
+export const toOpenCollectionResponseHeaders = (headers: BrunoFolderRequest['headers']): HttpResponseHeader[] | undefined => {
+  if (!headers?.length) {
+    return undefined;
+  }
+
+  const ocHeaders = headers.map((header: BrunoKeyValue): HttpResponseHeader => ({
+    name: header.name || '',
+    value: header.value || ''
+  }));
+
+  return ocHeaders.length ? ocHeaders : undefined;
+};
+
+export const toBrunoHttpHeaders = (headers: HttpRequestHeader[] | HttpResponseHeader[] | null | undefined): BrunoKeyValue[] | undefined => {
+  if (!headers?.length) {
+    return undefined;
+  }
+
+  const brunoHeaders = headers.map((header): BrunoKeyValue => {
+    const brunoHeader: BrunoKeyValue = {
+      uid: uuid(),
+      name: header.name || '',
+      value: header.value || '',
+      enabled: ('disabled' in header) ? header.disabled !== true : true
+    };
+
+    return brunoHeader;
+  });
+
+  return brunoHeaders.length ? brunoHeaders : undefined;
+};

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

@@ -0,0 +1,57 @@
+import type { HttpRequestParam as BrunoHttpRequestParam } from '@usebruno/schema-types/requests/http';
+import type { HttpRequestParam } from '@opencollection/types/requests/http';
+import { uuid } from '../../../utils';
+
+export const toOpenCollectionParams = (params: BrunoHttpRequestParam[] | null | undefined): HttpRequestParam[] | undefined => {
+  if (!params?.length) {
+    return undefined;
+  }
+
+  const ocParams = params.map((param: BrunoHttpRequestParam): HttpRequestParam => {
+    const ocParam: HttpRequestParam = {
+      name: param.name || '',
+      value: param.value || '',
+      type: param.type
+    };
+
+    if (param?.description?.trim().length) {
+      ocParam.description = param.description;
+    }
+
+    if (param.enabled === false) {
+      ocParam.disabled = true;
+    }
+
+    return ocParam;
+  });
+
+  return ocParams.length ? ocParams : undefined;
+};
+
+export const toBrunoParams = (params: HttpRequestParam[] | null | undefined): BrunoHttpRequestParam[] | undefined => {
+  if (!params?.length) {
+    return undefined;
+  }
+
+  const brunoParams = params.map((param: HttpRequestParam): BrunoHttpRequestParam => {
+    const brunoParam: BrunoHttpRequestParam = {
+      uid: uuid(),
+      name: param.name || '',
+      value: param.value || '',
+      type: param.type,
+      enabled: param.disabled !== true
+    };
+
+    if (param.description) {
+      if (typeof param.description === 'string' && param.description.trim().length) {
+        brunoParam.description = param.description;
+      } else if (typeof param.description === 'object' && param.description.content?.trim().length) {
+        brunoParam.description = param.description.content;
+      }
+    }
+
+    return brunoParam;
+  });
+
+  return brunoParams.length ? brunoParams : undefined;
+};

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

@@ -0,0 +1,64 @@
+import type { Scripts, Script } from '@opencollection/types/common/scripts';
+import type { FolderRequest as BrunoFolderRequest } from '@usebruno/schema-types/collection/folder';
+import type { HttpRequest as BrunoHttpRequest } from '@usebruno/schema-types/requests/http';
+import type { WebSocketRequest as BrunoWebSocketRequest } from '@usebruno/schema-types/requests/websocket';
+import type { GrpcRequest as BrunoGrpcRequest } from '@usebruno/schema-types/requests/grpc';
+
+export const toOpenCollectionScripts = (request: BrunoFolderRequest | BrunoHttpRequest | BrunoWebSocketRequest | BrunoGrpcRequest | null | undefined): Scripts | undefined => {
+  const ocScripts: Scripts = [];
+
+  if (request?.script?.req?.trim().length) {
+    ocScripts.push({
+      type: 'before-request',
+      code: request.script.req.trim()
+    });
+  }
+  if (request?.script?.res?.trim().length) {
+    ocScripts.push({
+      type: 'after-response',
+      code: request.script.res.trim()
+    });
+  }
+  if (request?.tests?.trim().length) {
+    ocScripts.push({
+      type: 'tests',
+      code: request.tests.trim()
+    });
+  }
+
+  return ocScripts.length > 0 ? ocScripts : undefined;
+};
+
+export const toBrunoScripts = (scripts: Scripts | null | undefined): {
+  script?: { req?: string; res?: string };
+  tests?: string;
+} | undefined => {
+  if (!scripts || !Array.isArray(scripts) || scripts.length === 0) {
+    return undefined;
+  }
+
+  const brunoScripts: {
+    script?: { req?: string; res?: string };
+    tests?: string;
+  } = {};
+
+  for (const script of scripts) {
+    if (script.type === 'before-request' && script.code) {
+      if (!brunoScripts.script) {
+        brunoScripts.script = {};
+      }
+      brunoScripts.script.req = script.code;
+    }
+    if (script.type === 'after-response' && script.code) {
+      if (!brunoScripts.script) {
+        brunoScripts.script = {};
+      }
+      brunoScripts.script.res = script.code;
+    }
+    if (script.type === 'tests' && script.code) {
+      brunoScripts.tests = script.code;
+    }
+  }
+
+  return Object.keys(brunoScripts).length > 0 ? brunoScripts : undefined;
+};