cloudapi-gql/lib/formatters.js

'use strict';

const ForceArray = require('force-array');
const Hasha = require('hasha');
const FWRule = require('fwrule');
const Uniq = require('lodash.uniq');

const Handlers = require('./handlers');
const Utils = require('./utils');


module.exports = {
  User: {
    keys: (root, args, request) => {
      return Handlers.keys(request.plugins.cloudapi.fetch, args);
    }
  },
  Machine: {
    brand: ({ brand }) => { return (brand ? brand.toUpperCase() : brand); },

    state: ({ state }) => { return (state ? state.toUpperCase() : state); },

    image: (root, args, request) => {
      return Handlers.image(request.plugins.cloudapi.fetch, { id: root.image });
    },

    // eslint-disable-next-line camelcase
    primary_ip: ({ primaryIp }) => { return primaryIp; },

    tags: (root, { name }, request) => {
      const { id: machine } = root;

      return Handlers.tags(request.plugins.cloudapi.fetch, { machine, name });
    },

    metadata: (root, { name }, request) => {
      const { id: machine } = root;
      return Handlers.metadata(request.plugins.cloudapi.fetch, { machine, name });
    },

    networks: async (root, args, request) => {
      const networks = [];
      for (const id of root.networks) {
        const network = await Handlers.network(request.plugins.cloudapi.fetch, { id });
        networks.push(network);
      }

      return networks;
    },

    // eslint-disable-next-line camelcase
    package: (root, args, request) => {
      return Handlers.package(request.plugins.cloudapi.fetch, { name: root.package });
    },

    snapshots: (root, { name }, request) => {
      const { id: machine } = root;
      return Handlers.snapshots(request.plugins.cloudapi.fetch, { machine, name });
    },

    // eslint-disable-next-line camelcase
    firewall_rules: (root, { id }, request) => {
      const { id: machine } = root;
      return Handlers.firewall_rules(request.plugins.cloudapi.fetch, { machine, id });
    },

    actions: (root, args, request) => {
      const { id: machine } = root;
      return Handlers.actions(request.plugins.cloudapi.fetch, { machine });
    }
  },
  Image: {
    os: ({ os }) => { return (os ? os.toUpperCase() : os); },

    state: ({ state }) => { return (state ? state.toUpperCase() : state); },

    type: ({ type }) => { return (type ? type.replace('-', '_').toUpperCase() : type); }
  },
  Action: {
    name: ({ action }) => { return action; },

    parameters: ({ parameters }) => { return Utils.toNameValues(parameters); }
  },
  Caller: {
    type: ({ type }) => { return (type ? type.toUpperCase() : type); },

    // eslint-disable-next-line camelcase
    key_id: ({ keyId }) => { return keyId; }
  },
  FirewallRule: {
    machines: ({ id }, args, request) => {
      return request.plugins.cloudapi.fetch(`/fwrules/${id}/machines`);
    },
    rule_str: ({ rule }) => { return rule; },
    rule_obj: ({ rule }) => {
      const parsed = FWRule.parse(rule);
      const _from = ForceArray(parsed.from);
      const _to = ForceArray(parsed.to);

      const getTags = (partial) => {
        return partial
          .map((partial) => { return ForceArray(partial); })
          .filter((partial) => { return partial[0] === 'tag'; })
          .map((partial) => { return [partial[0], ForceArray(partial[1])]; })
          .filter((partial) => { return partial[1]; })
          .map((partial) => { return partial[1][0]; })
          .filter(Boolean);
      };

      const isWildcard = (
        _from.some((frm) => { return frm[0] === 'wildcard'; }) &&
        _to.some((to) => { return to[0] === 'wildcard'; })
      );

      const tags = Uniq(getTags(_from).concat(getTags(_to)));

      return {
        ...parsed,
        isWildcard,
        tags
      };
    }
  },
  Snapshot: {
    state: ({ state }) => { return (state ? state.toUpperCase() : state); },
    id: ({ name }) => { return Hasha(name); }
  },
  ImageError: {
    code: ({ code }) => { return (code ? code.toUpperCase() : code); }
  },
  ImageFile: {
    compression: ({ compression }) => {
      return (compression ? compression.toUpperCase() : compression);
    }
  },
  Network: {
    machines: async ({ id, fabric }, args, request) => {
      if (!fabric) {
        return [];
      }

      const machines = await Handlers.machines(request.plugins.cloudapi.fetch, {});

      return ForceArray(machines).filter(({ networks }) => {
        return ForceArray(networks).some((network) => { return network === id; });
      });
    }
  }
};