Clean graphql response : Remove edges, node and __typename from graphql response

clean-graphql.js

/**
   * Remove edges, node and __typename from graphql response
   *
   * @param {Object} input - The graphql response
   * @returns {Object} Clean graphql response
   */
  const cleanGraphQLResponse = function(input) {
    if (!input) return null
    const output = {}
    const isObject = obj => {
      return obj !== null && typeof obj === 'object' && !Array.isArray(obj)
    }

    Object.keys(input).forEach(key => {
      if (input[key] && input[key].edges) {
        output[key] = input[key].edges.map(edge =>
          cleanGraphQLResponse(edge.node)
        )
      } else if (isObject(input[key])) {
        output[key] = cleanGraphQLResponse(input[key])
      } else if (key !== '__typename') {
        output[key] = input[key]
      }
    })

    return output
  }

Good work! Had to add a primitive type check because this was splitting my strings to single character arrays

/**
 * Remove edges, node and __typename from graphql response
 *
 * @param {Object} input - The graphql response
 * @returns {Object} Clean graphql response
 */
const cleanGraphQLResponse = function (input) {
  if (!input) return null;

  const isPrimitiveType = (test) => {
    return test !== Object(test);
  };

  if (isPrimitiveType(input)) return input;

  const output = {};
  const isObject = (obj) => {
    return obj !== null && typeof obj === 'object' && !Array.isArray(obj);
  };

  Object.keys(input).forEach((key) => {
    if (input[key] && input[key].edges) {
      output[key] = input[key].edges.map((edge) =>
        cleanGraphQLResponse(edge.node),
      );
    } else if (isObject(input[key])) {
      output[key] = cleanGraphQLResponse(input[key]);
    } else if (key !== '__typename') {
      output[key] = input[key];
    }
  });

  return output;
};

function transformObject(obj) {
  if (!obj || ["string", "boolean", "number"].includes(typeof obj)) {
    return obj;
  }

  if (Array.isArray(obj)) {
    return obj.map(transformObject);
  } else if (obj.hasOwnProperty("edges")) {
    return obj.edges.map((edge) => transformObject(edge.node));
  }

  return Object.keys(obj).reduce((result, key) => {
    const r = transformObject(obj[key]);
    if (key === "node") {
      return r;
    }
    result[key] = r;
    return result;
  }, {});
}

// transformObject(query?.edges);

Typescript

type Json =
  | { [key: string]: Json }
  | Json[]
  | string
  | number
  | boolean
  | null;

type JsonObj = { [key: string]: Json };

function transformObject(obj: Json): Json {
  if (isObject(obj)) {
    if (obj.edges && Array.isArray(obj.edges)) {
      return obj.edges.map((edge) => {
        if (edge && isObject(edge)) {
          return transformObject(edge.node);
        }

        return edge;
      });
    }

    return Object.keys(obj).reduce((result: JsonObj, key) => {
      const value = obj[key];
      result[key] = isObject(value) ? transformObject(value) : obj[key];
      return result;
    }, {} as JsonObj);
  }

  if (Array.isArray(obj)) {
    return obj.map(transformObject);
  }

  return obj;
}

function isObject(input: Json): input is JsonObj {
  return typeof input === "object" && input !== null && !Array.isArray(input);
}