Code Helper Guide for "GraphQL in Action"

{
  person(personID: 4) {
    name
    birthYear
    homeworld {
      name
    }
    filmConnection {
      films {
        title
      }
    }
  }
}

{
  person(personID: 4) {
    name
    birthYear
  }
}

{
  viewer {
    repositories(last: 10) {
      nodes {
        name
        description
      }
    }
  }
}

{
  licenses {
    name
    url
  }
}

{
  repository(owner: "facebook", name: "graphql") {
    issues(first: 10) {
      nodes {
        title
        createdAt
        author {
          login
        }
      }
    }
  }
}

mutation {
  addStar(input: {starrableId: "MDEwOlJlcG9zaXRvcnkzODM0MjIyMQ=="}) {
    starrable {
      stargazers {
        totalCount
      }
    }
  }
}

{
  repository(name: "graphql", owner: "facebook") {
    id
  }
}

query GetIssueInfo {
  repository(owner: "jscomplete", name: "graphql-in-action") {
    issue(number: 1) {
      id
      title
    }
  }
}

mutation AddCommentToIssue {
  addComment(input: {
    subjectId: "MDU6SXNzdWUzMDYyMDMwNzk=",
    body: "Hello GraphQL"
  }) {
    commentEdge {
      node {
        createdAt
      }
    }
  }
}

{
  __schema {
    types {
      name
      description
    }
  }
}

{
  __type(name: "Commit") {
    fields {
      name
      args {
        name
      }
    }
  }
}

query OrgInfo {
  organization(login: "facebook") {
    name
    description
    websiteUrl
  }
}

query First10Repos {
  organization(login: "facebook") {
    name
    description
    websiteUrl
    repositories(first: 10) {
      nodes {
        name
      }
    }
  }
}

query orgReposByName {
  organization(login: "facebook") {
    repositories(first:10, orderBy:{field: NAME, direction: ASC}) {
      nodes {
        name
      }
    }
  }
}

query OrgPopularRepos {
  organization(login: "facebook") {
    repositories(first:10, orderBy:{field: STARGAZERS, direction: DESC}) {
      nodes {
        name
      }
    }
  }
}

query OrgRepoConnectionExample {
  organization(login: "facebook") {
    repositories(first:10, orderBy:{field: STARGAZERS, direction: DESC}) {
      edges {
        cursor
        node {
          name
        }
      }
    }
  }
}

query OrgPopularReposPage2 {
  organization(login: "facebook") {
    repositories(
      first: 10,
      after: "Y3Vyc29yOnYyOpLNOE7OAeErrQ==",
      orderBy: {field: STARGAZERS, direction: DESC}
    ) {
      edges {
        cursor
        node {
          name
        }
      }
    }
  }
}

query OrgReposMetaInfoExample {
  organization(login: "facebook") {
    repositories(
      first: 10,
      after: "Y3Vyc29yOnYyOpLNOE7OAeErrQ==",
      orderBy: {field: STARGAZERS, direction: DESC}
    ) {
      totalCount
      pageInfo {
        hasNextPage
      }
      edges {
        cursor
        node {
          name
        }
      }
    }
  }
}

query SearchExample {
  repository(owner: "twbs", name: "bootstrap") {
    projects(search: "v4.1", first: 10) {
      nodes {
        name
      }
    }
  }
}

query FilterExample {
  viewer {
    repositories(first: 10, affiliations: OWNER) {
      totalCount
      nodes {
        name
      }
    }
  }
}

mutation StarARepo {
  addStar(input: {starrableId: "MDEwOlJlcG9zaXRvcnkzODM0MjIyMQ=="}) {
    starrable {
      stargazers {
        totalCount
      }
    }
  }
}

query ProfileInfo {
  user(login: "samerbuna") {
    name
    company
    bio
  }
}

query ProfileInfoWithAlias {
  user(login: "samerbuna") {
    name
    companyName: company
    bio
  }
}

query AllDirectives {
  __schema {
    directives {
      name
      description
      locations
      args {
        name
        description
        defaultValue
      }
    }
  }
}

query OrgInfo($orgLogin: String!) {
  organization(login: $orgLogin) {
    name
    description
    websiteUrl
  }
}

query OrgInfoWithDefault($orgLogin: String = "facebook") {
  organization(login: $orgLogin) {
    name
    description
    websiteUrl
  }
}

query OrgInfo($orgLogin: String!, $fullDetails: Boolean!) {
  organization(login: $orgLogin) {
    name
    description
    websiteUrl @include(if: $fullDetails)
  }
}

query OrgInfo($orgLogin: String!, $partialDetails: Boolean!) {
  organization(login: $orgLogin) {
    name
    description
    websiteUrl @skip(if: $partialDetails)
  }
}

query OrgInfo($orgLogin: String!, $partialDetails: Boolean!) {
  organization(login: $orgLogin) {
    name
    description
    websiteUrl @skip(if: $partialDetails) @include(if: false)
  }
}

query MyRepos {
  viewer {
    ownedRepos: repositories(affiliations: OWNER, first: 10) {
      nodes {
        nameWithOwner
        description
        forkCount
      }
    }
    orgsRepos: repositories(affiliations: ORGANIZATION_MEMBER, first: 10) {
      nodes {
        nameWithOwner
        description
        forkCount
      }
    }
  }
}

query MyRepos {
  viewer {
    ownedRepos: repositories(affiliations: OWNER, first: 10) {
      ...repoInfo
    }
    orgsRepos: repositories(affiliations: ORGANIZATION_MEMBER, first: 10) {
      ...repoInfo
    }
  }
}

fragment repoInfo on RepositoryConnection {
  nodes {
    nameWithOwner
    description
    forkCount
  }
}

query InlineFragmentExample {
  repository(owner: "facebook", name: "graphql") {
    ref(qualifiedName: "master") {
      target {
        ... on Commit {
          message
        }
      }
    }
  }
}

query RepoUnionExample {
  repository(owner: "facebook", name: "graphql") {
    issueOrPullRequest(number: 3) {
      __typename
    }
  }
}

query RepoUnionExampleFull {
  repository(owner: "facebook", name: "graphql") {
    issueOrPullRequest(number: 5) {
      ... on PullRequest {
        merged
        mergedAt
      }
      ... on Issue {
        closed
        closedAt
      }
    }
  }
}

query TestSearch {
  search(first: 100, query: "graphql", type: USER) {
    nodes {
      ... on User {
        name
        bio
      }
      ... on Organization {
        login
        description
      }
    }
  }
}

CREATE TABLE azdev.users (
  id serial PRIMARY KEY,

  email text NOT NULL UNIQUE,
  hashed_password text NOT NULL,

  first_name text,
  last_name text,

  is_admin boolean NOT NULL DEFAULT false,

  hashed_auth_token text,

  created_at timestamp without time zone NOT NULL
    DEFAULT (now() at time zone 'utc'),

  CHECK (lower(email) = email)
);

CREATE TABLE azdev.needs (
  id serial PRIMARY KEY,

  content text NOT NULL,
  tags text,

  user_id integer NOT NULL,

  is_public boolean NOT NULL,
  is_featured boolean NOT NULL DEFAULT FALSE,

  created_at timestamp without time zone NOT NULL
    DEFAULT (now() at time zone 'utc'),

  FOREIGN KEY (user_id) REFERENCES azdev.users,
  CHECK (is_public = true OR is_featured = false)
);

CREATE TABLE azdev.approaches (
  id serial PRIMARY KEY,

  content text NOT NULL,

  user_id integer NOT NULL,
  need_id integer NOT NULL,

  vote_count integer NOT NULL DEFAULT 0,

  created_at timestamp without time zone NOT NULL
    DEFAULT (now() at time zone 'utc'),

  FOREIGN KEY (user_id) REFERENCES azdev.users,
  FOREIGN KEY (need_id) REFERENCES azdev.needs
);

db.createCollection("approachDetails", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["pgId"],
      properties: {
        pgId: {
          bsonType: "int",
          description: "must be an integer and is required"
        },
      }
    }
  }
});

type Query {
  currentTime: String
  numbersInRange(begin: Int!, end: Int!): NumbersInRange
  needFeaturedList: [Need!]!
  search(term: String!): [SearchResultItem!]!
  needInfo(id: ID!): Need
  me: Me
}

"""Aggregate info on a range of numbers"""
type NumbersInRange {
  sum: Int!
  count: Int!
}

type Need implements SearchResultItem {
  id: ID!
  createdAt: String!
  content: String!
  tags: [String!]!
  approachCount: Int!
  author: User!
  approachList: [Approach!]!
}

interface SearchResultItem {
  id: ID!
  content: String!
}

type User {
  id: ID!
  email: String
  name: String
  createdAt: String!
}

type Approach implements SearchResultItem {
  id: ID!
  createdAt: String!
  content: String!
  voteCount: Int!
  need: Need!
  author: User!
  detailList: [ApproachDetail!]!
}

type ApproachDetail {
  content: String!
  category: ApproachDetailCategory!
}

enum ApproachDetailCategory {
  NOTE
  EXPLANATION
  WARNING
}

type Me {
  id: ID!
  email: String
  name: String
  createdAt: String!
  needList: [Need!]!
}

type Mutation {
  userCreate(input: UserInput!): UserPayload
  userLogin(input: AuthInput!): UserPayload
  needCreate(input: NeedInput!): NeedPayload
  approachCreate(needId: ID!, input: ApproachInput!): ApproachPayload
  approachVote(approachId: ID!, input: ApproachVoteInput!): ApproachPayload
}

type UserPayload {
  errors: [UserError!]!
  user: User
  authToken: String
}

type UserError {
  message: String!
  field: String
}

input UserInput {
  email: String!
  password: String!
  firstName: String
  lastName: String
}

input AuthInput {
  email: String!
  password: String!
}

type NeedPayload {
  errors: [UserError!]!
  need: Need
}

input NeedInput {
  content: String!
  tags: [String!]!
  private: Boolean!
}

type ApproachPayload {
  errors: [UserError!]!
  approach: Approach
}

input ApproachInput {
  content: String!
  detailList: [ApproachDetailInput!]!
}

input ApproachDetailInput {
  content: String!
  category: ApproachDetailCategory!
}

input ApproachVoteInput {
  up: Boolean!
}

export const pgConfig = {
  database: process.env.PG_DATABASE,
};

export const mongoConfig = {
  database: process.env.MONGO_DATABASE,
  url: process.env.MONGO_URL,
};

export PG_DATABASE="YOUR_PG_DEV_DB_NAME_HERE"

export MONGO_DATABASE="azdev"
export MONGO_URL="mongodb://localhost:27017"

import pg from 'pg';
import { pgConfig } from '../config.js';

export default async () => {
  const pgPool = new pg.Pool(pgConfig);

  // Test the connection
  const client = await pgPool.connect();
  const tableCountResp = await client.query(
    'select count(*) from information_schema.tables where table_schema = $1;',
    ['azdev']
  );
  client.release();

  console.log(
    'Connected to PostgreSQL | Tables count:',
    tableCountResp.rows[0].count
  );

  pgPool.on('error', (err) => {
    console.error('Unexpected PG client error', err);
    process.exit(-1);
  });

  return {
    pgPool,
    pgClose: async () => await pgPool.end(),
  };
};

import mdb from 'mongodb';
import { mongoConfig } from '../config.js';

export default async () => {
  const client = new mdb.MongoClient(mongoConfig.url, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
  });
  try {
    await client.connect();
    const mdb = client.db(mongoConfig.database);

    // Test the connection
    const collections = await mdb.collections();
    console.log(
      'Connected to MongoDB | Collections count:',
      collections.length
    );

    return {
      mdb,
      mdbClose: () => client.close(),
    };
  } catch (err) {
    console.error('Error in MongoDB Client', err);
    process.exit(1);
  }
};

const switchStatement1 = `switch (expression) {
  case value1:
    // do something when expression === value1
    break;
  case value2:
    // do something when expression === value2
    break;
  default:
    // do something when expression does not equal any of the values above
}`;

const switchStatement2 = `function doSomethingFor(expression) {
  switch (expression) {
    case value1:
      // do something when expression === value1
      return;
    case value2:
      // do something when expression === value2
      return;
    default:
      // do something when expression does not equal any of the values above
  }
}`;

const babelReactEnv = `module.exports = {
  presets: [
    ''@babel/react'',
    [
      ''@babel/env'',
      {
        modules: ''commonjs'',
        targets: [
          ''> 1%'',
          ''last 3 versions'',
          ''ie >= 9'',
          ''ios >= 8'',
          ''android >= 4.2'',
        ],
      },
    ],
  ],
  plugins: [
    [''@babel/plugin-proposal-class-properties'', {loose: true}],
  ],
};`;

export default {
  0: `
    INSERT INTO azdev.users (email, hashed_password, hashed_auth_token, is_admin)
    VALUES ('[email protected]', crypt('testPass123', gen_salt('bf')), crypt('testToken123', gen_salt('bf')), FALSE)
    RETURNING id;
  `,

  1: {
    need: `
      INSERT INTO azdev.needs (content, tags, user_id, is_public)
      VALUES ('Caluclate the sum of numbers in a JavaScript array', 'code,javascript', $1, TRUE)
      RETURNING id;`,
    approaches: [
      {
        pg: `
          INSERT INTO azdev.approaches (content, user_id, need_id, vote_count)
          VALUES ('arrayOfNumbers.reduce((acc, curr) => acc + curr, 0)', $1, $2, 7)
          RETURNING id;`,
        mongo: {
          explanations: [
            'The `reduce` method invokes its callback function (the first argument) on every item in `arrayOfNumbers`. Each invokation supplies the callback function with an "accumulator" argument and the "current" item for that invokation. What the callback function returns becomes the new value for the accumulator. The initial value of the accumulator is the second argument to `reduce`. By starting with 0 and always returning the sum of the accumulator and the current number in the array, the final result will be the sum of all numbers in `arrayOfNumbers`.',
          ],
        },
      },
    ],
  },

  2: {
    need: `
      INSERT INTO azdev.needs (content, tags, user_id, is_public, is_featured)
      VALUES ('Get rid of only the unstaged changes since the last git commit', 'command,git', $1, TRUE, TRUE)
      RETURNING id;`,
    approaches: [
      {
        pg: `
          INSERT INTO azdev.approaches (content, user_id, need_id)
          VALUES ('git diff | git apply --reverse', $1, $2)
          RETURNING id;`,
        mongo: {
          notes: [
            'This will work if you have staged changes (that you want to keep) or even untracked files. It will only git rid of the unstaged changes.',
          ],
        },
      },
    ],
  },

  3: {
    need: `
      INSERT INTO azdev.needs (content, tags, user_id, is_public, is_featured)
      VALUES ('The syntax for a switch statement (AKA case statement) in JavaScript', 'code,javascript', $1, TRUE, TRUE)
      RETURNING id;`,
    approaches: [
      {
        pg: `
          INSERT INTO azdev.approaches (content, user_id, need_id, vote_count)
          VALUES ('${switchStatement1}', $1, $2, 5)
          RETURNING id;`,
        mongo: {
          notes: [
            'The `break` statements are needed. Without them, JavaScript will continue to execute all the lines in all the other cases after the one that was matched. That is rarely the intended behaviour (altough you can use it to define multiple cases that are intended to execute the same code. For example, do something if `expression` equals either `value1` or `value2`)',
          ],
        },
      },
      {
        pg: `
          INSERT INTO azdev.approaches (content, user_id, need_id, vote_count)
          VALUES ('${switchStatement2}', $1, $2, 18)
          RETURNING id;`,
        mongo: {
          explanations: [
            'Because the function returns for each case, there is no need to "break" out of that case. You can make the function optionally return a value based on the expression as well.',
          ],
        },
      },
    ],
  },

  4: {
    need: `
      INSERT INTO azdev.needs (content, tags, user_id, is_public)
      VALUES ('Babel configuration file for "react" and "env" presets with a list of plugins', 'config,javascript,node', $1, TRUE)
      RETURNING id;`,
    approaches: [
      {
        pg: `
          INSERT INTO azdev.approaches (content, user_id, need_id)
          VALUES ('${babelReactEnv}', $1, $2)
          RETURNING id;`,
        mongo: {
          notes: [
            'This will only work for Babel versions > 7.x. Older Babels require a different configuration.',
          ],
        },
      },
    ],
  },

  5: {
    need: `
      INSERT INTO azdev.needs (content, tags, user_id, is_public, is_featured)
      VALUES ('Create a secure one-way hash for a text value (like a password) in Node', 'code,node', $1, TRUE, TRUE)
      RETURNING id;`,
    approaches: [
      {
        pg: `
          INSERT INTO azdev.approaches (content, user_id, need_id)
          VALUES ('const bcrypt = require(''bcrypt'');\nconst hashedPass = bcrypt.hashSync(''testPass123'', 10);', $1, $2)
          RETURNING id;`,
        mongo: {
          explanations: [
            'The second argument to hashSync (or hash) is for the "salt" to be used to hash the text. When specified as a number then a salt will be generated with the specified number of rounds and used.',
          ],
          notes: [
            'To do the hasing asynchronously, use the `bycrypt.hash` method. It returns a promise.',
            'To compare hashed texts together, bcrypt has a `compareSync` (and `compare`) methods',
          ],
        },
      },
    ],
  },
};

import pgClient from '../lib/db-clients/pg.js';
import mdbClient from '../lib/db-clients/mongo.js';
import data from './data.js';

const importAllData = async () => {
  console.info('Importing seed data');

  const { pgPool, pgClose } = await pgClient();
  const { mdb, mdbClose } = await mdbClient();

  /* The following "dangerous" 2 lines can be used to reset
     your database and delete all existing data.
     Make sure you're running them against a local databases! */
  await pgPool.query('TRUNCATE TABLE azdev.users CASCADE');
  await mdb.collection('approachDetails').deleteMany({});

  let pgResp;
  pgResp = await pgPool.query(data[0]);
  const userId = pgResp.rows[0].id;

  for (let i = 1; i <= 5; i++) {
    const { need, approaches } = data[i];
    pgResp = await pgPool.query(need, [userId]);
    const needId = pgResp.rows[0].id;

    for (const approach of approaches) {
      pgResp = await pgPool.query(approach.pg, [userId, needId]);
      const approachId = pgResp.rows[0].id;

      await mdb.collection('approachDetails').insertOne({
        pgId: approachId,
        ...approach.mongo,
      });
    }
  }

  console.info('Done importing seed data');
  pgClose();
  mdbClose();
};

importAllData();

SELECT * FROM azdev.users;

SELECT * FROM azdev.needs;

SELECT * FROM azdev.approaches;

db.approachDetails.find({});

import { graphql } from 'graphql';
import { schema, rootValue } from './schema/index.js';

const executeGraphQLRequest = async request => {
  const resp = await graphql(schema, request, rootValue);

  console.log(resp.data);
};

executeGraphQLRequest(process.argv[2]);

import express from 'express';
import graphqlHTTP from 'express-graphql';
import { schema, rootValue } from './schema/index.js';

const server = express();

server.listen(8484, () => {
  console.log('API server is running');
});

server.use(
  '/',
  graphqlHTTP({
    schema,
    rootValue,
    graphiql: true,
  })
);

import {
  GraphQLID,
  GraphQLObjectType,
  GraphQLString,
  GraphQLNonNull,
  GraphQLList,
} from 'graphql';

const Need = new GraphQLObjectType({
  name: 'Need',
  fields: {
    id: {
      type: new GraphQLNonNull(GraphQLID),
    },
    content: {
      type: new GraphQLNonNull(GraphQLString),
    },
    tags: {
      type: new GraphQLNonNull(
        new GraphQLList(new GraphQLNonNull(GraphQLString))
      ),
    },
    createdAt: {
      type: new GraphQLNonNull(GraphQLString),
    },
  },
});

export default Need;

import express from 'express';
import graphqlHTTP from 'express-graphql';
import { schema } from './schema/index.js';

import pgClient from './db-clients/pg.js';

const startGraphQLWebServer = async () => {
  const { pgPool } = await pgClient();

  const server = express();
  server.use(
    '/',
    graphqlHTTP({
      schema,
      context: { pgPool },
      graphiql: true,
    })
  );

  server.listen(8484, () => {
    console.log('API server is running');
  });
};

startGraphQLWebServer();

import {
  // ...
  GraphQLList,
} from 'graphql';

import Need from './types/need.js';

// ...

const QueryType = new GraphQLObjectType({
  name: 'Query',
  fields: {
    // ...
    needFeaturedList: {
      type: new GraphQLNonNull(
        new GraphQLList(new GraphQLNonNull(Need))
      ),
      resolve: async (source, args, { pgPool }) => {
        const pgResp = await pgPool.query(`
          SELECT * FROM azdev.needs WHERE is_featured = true
        `);
        return pgResp.rows;
      },
    },
  },
});

// ...

import pgClient from '../db-clients/pg.js';

const sqls = {
  featuredNeeds:
    'SELECT * FROM azdev.needs WHERE is_featured = true;',
};

const pgApiWrapper = async () => {
  const { pgPool } = await pgClient();

  const pgQuery = (text, params) => pgPool.query(text, params);

  return {
    needs: {
      allFeatured: async () => {
        const pgResp = await pgQuery(sqls.featuredNeeds);
        return pgResp.rows;
      },
    },
  };
};

export default pgApiWrapper;

import pgApiWrapper from './db-api/pg.js';

const server = express();

const startGraphQLWebServer = async () => {
  const pgApi = await pgApiWrapper();

  server.use(
    '/',
    graphqlHTTP({
      schema,
      context: { pgApi },
      graphiql: true,
    })
  );

needFeaturedList: {
  type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(Need))),
  resolve: async (source, args, { pgApi }) => {
    return pgApi.needs.allFeatured();
  },
},

{
  needFeaturedList {
    id
    content
    tags
    createdAt

    author {
      id
      email
      name
      createdAt
    }

    approachList {
      id
      content
      createdAt

      author {
        id
        email
        name
        createdAt
      }
    }
  }
}

const sqls = {
  // ...
  userInfo: 'SELECT * FROM azdev.users WHERE id = $1',
};

const pgApiWrapper = async () => {
  // ...
  return {
    // ...
    users: {
      byId: async (userId) => {
        const pgResp = await pgQuery(sqls.userInfo, [userId]);
        return pgResp.rows[0];
      },
    },
  };
};

import {
  GraphQLID,
  GraphQLObjectType,
  GraphQLString,
  GraphQLNonNull,
} from 'graphql';

const User = new GraphQLObjectType({
  name: 'User',
  fields: {
    id: {
      type: new GraphQLNonNull(GraphQLID),
    },
    email: {
      type: GraphQLString,
    },
    name: {
      type: GraphQLString,
      resolve: ({ first_name, last_name }) => `${first_name} ${last_name}`,
    },
    createdAt: {
      type: new GraphQLNonNull(GraphQLString),
      resolve: ({ created_at }) => created_at.toISOString(),
    },
  },
});

export default User;

import User from './user.js';

const Need = new GraphQLObjectType({
  name: 'Need',
  fields: {
    // ...

    author: {
      type: new GraphQLNonNull(User),
      resolve: (source, args, { pgApi }) =>
        pgApi.users.byId(source.user_id),
    },
  },
});

name: {
  type: new GraphQLNonNull(GraphQLString),
  resolve: ({ first_name, last_name }) =>
    [first_name, last_name].filter(Boolean).join(' '),
},

const views = {
  needsAndUsers: `
    SELECT n.*,
      u.id AS author_id,
      u.email AS author_email,
      u.first_name AS author_first_name,
      u.last_name AS author_last_name,
      u.created_at AS author_created_at
    FROM azdev.needs n
    JOIN azdev.users u ON (n.user_id = u.id)
  `,
};

const sqls = {
  featuredNeeds: `
    SELECT *
    FROM (${views.needsAndUsers}) nau
    WHERE is_featured = true;
  `,
};

import { extractPrefixedColumns } from '../utils.js';

const Need = new GraphQLObjectType({
  name: 'Need',
  fields: {
    // ...

    author: {
      type: new GraphQLNonNull(User),
      resolve: prefixedObject =>
        extractPrefixedColumns({ prefixedObject, prefix: 'author' }),
    },
  },
});

export const extractPrefixedColumns = ({ prefixedObject, prefix }) => {
  const prefixRexp = new RegExp(`^${prefix}_(.*)`);
  return Object.entries(prefixedObject).reduce((acc, [key, value]) => {
    const match = key.match(prefixRexp);
    if (match) {
      acc[match[1]] = value;
    }
    return acc;
  }, {});
};

import Approach from './approach.js';

const Need = new GraphQLObjectType({
  name: 'Need',
  fields: {
    // ...
    approachList: {
      type: new GraphQLNonNull(
        new GraphQLList(new GraphQLNonNull(Approach))
      ),
      resolve: (source, args, { pgApi }) =>
        pgApi.needs.approachList(source.id),
    },
  },
});

import {
  GraphQLID,
  GraphQLObjectType,
  GraphQLString,
  GraphQLInt,
  GraphQLNonNull,
} from 'graphql';

import User from './user.js';

const Approach = new GraphQLObjectType({
  name: 'Approach',
  fields: {
    id: {
      type: new GraphQLNonNull(GraphQLID),
    },
    content: {
      type: new GraphQLNonNull(GraphQLString),
    },
    voteCount: {
      type: new GraphQLNonNull(GraphQLInt),
      resolve: ({ vote_count }) => vote_count,
    },
    createdAt: {
      type: new GraphQLNonNull(GraphQLString),
      resolve: ({ created_at }) => created_at.toISOString(),
    },
    author: {
      type: new GraphQLNonNull(User),
      resolve: (source, args, { pgApi }) =>
        pgApi.users.byId(source.user_id),
    },
  },
});

export default Approach;

const sqls = {
  // ...
  approachesForNeed:
    'SELECT * FROM azdev.approaches WHERE need_id = $1',
};

const pgApiWrapper = async () => {
  // ...
  return {
    needs: {
      // ...
      approachList: async (needId) => {
        const pgResp = await pgQuery(sqls.approachesForNeed, [
          needId,
        ]);
        return pgResp.rows;
      },
    },
    // ...
  };
};