joyent-portal/cloudapi-graphql/src/schema/types/machine.js

const FirewallRuleType = require('./firewall-rule');
const DynamicObjectType = require('./dynamic-object');
const SnapshotType = require('./snapshot');
const api = require('../../api');

const {
  GraphQLBoolean,
  GraphQLString,
  GraphQLInputObjectType,
  GraphQLObjectType,
  GraphQLInt,
  GraphQLList,
  GraphQLID
} = require('graphql');

module.exports = new GraphQLObjectType({
  name: 'MachineType',
  description: 'An image contains the software packages that will be available on newly-provisioned instance. In the case of hardware virtual machines, the image also includes the operating system',
  fields: {
    id: {
      type: GraphQLID,
      description: 'Unique id for this instance'
    },
    name: {
      type: GraphQLString,
      description: 'The "friendly" name for this instance'
    },
    brand: {
      type: GraphQLString,
      description: 'The type of instance (e.g. lx)'
    },
    state: {
      type: GraphQLString,
      description: 'The current state of this instance (e.g. running)'
    },
    image: {
      type: GraphQLString,
      description: 'The image id this instance was provisioned with'
    },
    memory: {
      type: GraphQLInt,
      description: 'The amount of RAM this instance has (in MiB)'
    },
    disk: {
      type: GraphQLInt,
      description: 'The amount of disk this instance has (in MiB)'
    },
    metadata: {
      type: DynamicObjectType,
      description: 'Any additional metadata this instance has'
    },
    tags: {
      type: DynamicObjectType,
      description: 'Any tags this instance has',
      args: {
        name: {
          type: GraphQLString,
          description: 'Filter on the name of the tag'
        }
      },
      resolve: (root, args) => {
        const {
          tags: {
            get
          }
        } = api.machines;

        return !args.name ? root.tags : get({
          id: root.id,
          tag: args.name
        }).then((value) => {
          return {
            [args.name]: value
          };
        });
      }
    },
    created: {
      type: GraphQLString,
      description: 'When this instance was created'
    },
    updated: {
      type: GraphQLString,
      description: 'When this instance\'s details was last updated'
    },
    docker: {
      type: GraphQLBoolean,
      description: 'Whether this instance is a Docker container, if present',
      resolve: (root) => {
        return !!root.docker;
      }
    },
    ips: {
      type: new GraphQLList(GraphQLString),
      description: 'The IP addresses this instance has'
    },
    networks: {
      type: new GraphQLList(GraphQLString),
      description: 'The network UUIDs of the nics this instance has'
    },
    primaryIp: {
      type: GraphQLString,
      description: 'IP address of the primary nic of this instance'
    },
    firewall_enabled: {
      type: GraphQLBoolean,
      description: 'Whether firewall rules are enforced on this instance',
      resolve: (root) => {
        return !!root.firewall_enabled;
      }
    },
    firewall_rules: {
      type: new GraphQLList(FirewallRuleType),
      description: 'List of FirewallRules affecting this machine',
      resolve: (root) => {
        return api.firewallRules.listByMachine(root.id);
      }
    },
    compute_node: {
      type: GraphQLString,
      description: 'UUID of the server on which the instance is located'
    },
    'package': {
      type: GraphQLString,
      description: 'The id or name of the package used to create this instance'
    },
    snapshots: {
      type: new GraphQLList(SnapshotType),
      description: 'The snapshots based on this instance',
      args: {
        name: {
          type: GraphQLString,
          description: 'Filter on the name of the snapshot'
        }
      },
      resolve: (root, args) => {
        const {
          snapshot: {
            list,
            get
          }
        } = api.machines;

        return !args.id ? list(root) : get({
          id: root.id,
          name: args.name
        });
      }
    }
  }
});

module.exports.locality = new GraphQLInputObjectType({
  name: 'LocalityType',
  fields: {
    strict: {
      type: GraphQLBoolean,
      resolve: (root) => {
        return !!root.strict;
      }
    },
    near: {
      type: new GraphQLList(GraphQLID)
    },
    far: {
      type: new GraphQLList(GraphQLID)
    }
  }
});