apollo-boost#gql JavaScript Examples

mutation = gql`
  mutation DeviceOutletRemove($deviceid: String!, $outletid: String!) {
    viewer {
      devices {
        device(deviceid: $deviceid) {
          outlets {
            outlet(outletid: $outletid) {
              remove {
                ...DeviceFragment
              }
            }
          }
        }
      }
    }
  }
  ${DeviceFragment}
`

repository = () => {
    return gql`
    query {
        contributors_fyi @rest(type: "[Contributor]", path: "/repos/blocklytics/spells-fyi/contributors") {
            login
            avatar_url
          }

          contributors_subgraph @rest(type: "[Contributor]", path: "/repos/blocklytics/spells-subgraph/contributors") {
            login
            avatar_url
          }
      }
    `;
}

mutation = gql`
  mutation ServiceUpdate {
    viewer {
      service {
        update {
          id
          service {
            ...ServiceFragment
          }
        }
      }
    }
  }
  ${ServiceFragment}
`

GET_ENTITY_BY_TOKEN = gql`
  query getEntity($token: String!) {
    linkedToken(token: $token) {
      ... on FullProvider {
        id
        firstName
        lastName
        neighborhood
        city
        state
        country
        latitude
        address
        longitude
        facility
        email
        role
        description
        requests {
          type
          satisfied
        }
        active
      }
    }
  }
`

mutation = gql`
  mutation DeviceServiceUpdate($deviceid: String!) {
    viewer {
      devices {
        device(deviceid: $deviceid) {
          service {
            update {
              ...DeviceFragment
            }
          }
        }
      }
    }
  }
  ${DeviceFragment}
`

GET_PROVIDER = gql`
  query Provider($id: ID!) {
    provider(id: $id) {
      id
      firstName
      city
      state
      neighborhood
      role
      facility
      description
      active
      createdAt
      requests {
        type
        satisfied
      }
    }
  }
`

mutation = gql`
  mutation DeviceOutletStop($deviceid: String!, $outletid: String!) {
    viewer {
      devices {
        device(deviceid: $deviceid) {
          outlets {
            outlet(outletid: $outletid) {
              state {
                stop {
                  ...DeviceFragment
                }
              }
            }
          }
        }
      }
    }
  }
  ${DeviceFragment}
`

GET_PROVIDER = gql`
  query Provider($id: ID!) {
    provider(id: $id) {
      id
      firstName
      requests {
        type
        satisfied
      }
    }
  }
`

DeviceFragment = gql`
  fragment DeviceFragment on Device {
    id
    deviceid
    service {
      upgradable
      needRestart
    }
    state {
      online
    }
    outlets {
      list {
        ...DeviceOutletFragment
      }
    }
    inlets {
      list {
        ...DeviceInletFragment
      }
    }
  }
  ${DeviceOutletFragment}
  ${DeviceInletFragment}
`

GET_POSTS = gql`
{
  repository(owner: "${config.githubUserName}", name: "${config.githubRepo}") {
    issues(first: 100, states: OPEN, filterBy: { labels: "blog" }, orderBy: { direction: DESC, field: CREATED_AT }) {
      nodes {
        title
        body
        bodyHTML
        bodyText
        number
        labels(first: 100) {
          nodes {
            color
            name
            id
          }
        }
        author {
          url
          avatarUrl
          login
        }
        updatedAt
        id
      }
    }
  }
}
`

mutation = gql`
  mutation DeviceOutletStart($deviceid: String!, $inletid: String!) {
    viewer {
      devices {
        device(deviceid: $deviceid) {
          inlets {
            inlet(inletid: $inletid) {
              state {
                start {
                  ...DeviceFragment
                }
              }
            }
          }
        }
      }
    }
  }
  ${DeviceFragment}
`

GET_LABELLED_ISSUES = gql`
query ($repo: String!){
  repository(owner: "moja-global", name: $repo) {
    issues(orderBy: {field: CREATED_AT, direction: DESC},first:100,states:OPEN, labels:["good first issue"]) {
      edges {
        node {
          title
          url
          createdAt
          number
          author{
            avatarUrl
            login
          }
          labels(first:5) {
            edges {
              node {
                name
                color
              }
            }
          }
        }
      }
    }
  }
}`

mutation = gql`
  mutation DeviceOutletRemove($deviceid: String!, $inletid: String!) {
    viewer {
      devices {
        device (deviceid: $deviceid) {
          inlets {
            inlet(inletid: $inletid) {
              remove {
                ...DeviceFragment
              }
            }
          }
        }
      }
    }
  }
  ${DeviceFragment}
`

export default function locksByOwner() {
  return gql`
    query Locks($owner: String!) {
      locks(
        where: { owner: $owner }
        orderBy: creationBlock
        orderDirection: desc
      ) {
        address
        name
      }
    }
  `
}

mutation = gql`
  mutation DeviceInletCreate(
    $deviceid: String!
    $target: DeviceOutletTargetInput!
    $dest: EndpointInput!
  ) {
    viewer {
      devices {
        device(deviceid: $deviceid) {
          inlets {
            create(target: $target, dest: $dest) {
              ...DeviceFragment
            }
          }
        }
      }
    }
  }
  ${DeviceFragment}
`

getLanguagesByDraft = gql `
query($draftID: ID!){
    getLanguagesByDraft(draftID: $draftID){
        id
        draftID
        language
    }
}
`

GRAVATARS_QUERY = gql`
  query gravatars($where: Gravatar_filter!, $orderBy: Gravatar_orderBy!) {
    gravatars(first: 100, where: $where, orderBy: $orderBy, orderDirection: asc) {
      id
      owner
      displayName
      imageUrl
    }
  }
`

Get = gql`
  query Service {
    viewer {
      id
      service {
        ...ServiceFragment
      }
    }
  }
  ${ServiceFragment}
`

addEducationMutation = gql`
    mutation($input: EducationHistoryInput) {
        addEducationHistory(input: $input) {
            draftID
            schoolType
            schoolName
            startDate
            endDate
            certName
        }
    }
`

Get = gql`
  query Device($deviceid: String!) {
    viewer {
      id
      devices {
        device(deviceid: $deviceid) {
          ...DeviceFragment
        }
      }
    }
  }
  ${DeviceFragment}
`

addProjectMutation = gql`
    mutation($input: ProjectInput!) {
        addProject(input: $input){
            draftID
            title
            projectUrl
            description
            startDate
            endDate
        }
    }
`

ServiceFragment = gql`
  fragment ServiceFragment on Service {
    upgradable
    needRestart
    messages {
      type
      message
    }
  }
`

getAuthorDetails = gql`
  query($name: String) {
    author(name: $name) {
      name
      books {
        title
      }
    }
  }
`

DeviceInletFragment = gql`
  fragment DeviceInletFragment on DeviceInlet {
    id
    inletid
    target {
      deviceid
      outletid
    }
    dest {
      host
      port
    }
    state {
      active
      status
      target {
        id
        state {
          active
        }
      }
      worker {
        ip
      }
      hosts {
        ip
      }
    }
  }
`

CREATE_PROVIDER = gql`
  mutation CreateProvider(
    $firstName: String!
    $lastName: String
    $neighborhood: String
    $city: String!
    $state: String!
    $country: String!
    $email: String!
    $facility: String
    $role: String!
    $requests: [String!]!
    $description: String!
    $latitude: Float!
    $longitude: Float!
    $address: String!
  ) {
    createProvider(
      input: {
        firstName: $firstName
        lastName: $lastName
        neighborhood: $neighborhood
        city: $city
        state: $state
        country: $country
        email: $email
        facility: $facility
        role: $role
        requests: $requests
        description: $description
        latitude: $latitude
        longitude: $longitude
        address: $address
      }
    ) {
      errors
      editLink
      provider {
        id
      }
    }
  }
`

Get = gql`
  query {
    viewer {
      id
    }
  }
`

export default function Projects() {
  const [repo, setrepo] = useState([]);

  useEffect(() => {
    getRepoData();
  }, []);

  function getRepoData() {
    const client = new ApolloClient({
      uri: "https://api.github.com/graphql",
      request: (operation) => {
        operation.setContext({
          headers: {
            authorization: `Bearer ${atob(openSource.githubConvertedToken)}`,
          },
        });
      },
    });

    client
      .query({
        query: gql`
          {
            repositoryOwner(login: "${openSource.githubUserName}") {
              ... on User {
                pinnedRepositories(first: 6) {
                  edges {
                    node {
                      nameWithOwner
                      description
                      forkCount
                      stargazers {
                        totalCount
                      }
                      url
                      id
                      diskUsage
                      primaryLanguage {
                        name
                        color
                      }
                    }
                  }
                }
              }
            }
          }
        `,
      })
      .then((result) => {
        setrepoFunction(result.data.repositoryOwner.pinnedRepositories.edges);
        console.log(result);
      });
  }

  function setrepoFunction(array) {
    setrepo(array);
  }

  return (
    <div className="main" id="opensource">
      <h1 className="project-title">Open Source Projects</h1>
      <div className="repo-cards-div-main">
        {repo.map((v, i) => {
          return <GithubRepoCard repo={v} key={v.node.id} />;
        })}
      </div>
      <Button
        text={"More Projects"}
        className="project-button"
        href={greeting.githubProfile}
        newTab={true}
      />
    </div>
  );
}

getDraftQuery = gql`
    query($id: ID!) {
        getDraft(id: $id) {
            id
            name
            email
            
            education{
                id
                schoolType
                schoolName
                startDate
                endDate
                certName
            }
            work{
                id
                startDate
                endDate
                title
                description
                company
            }
            project{
                id            
                title
                projectUrl
                description
                startDate
                endDate
            }
            skill{
                id
                name
                skillType
            }
            hobbies{
                id
                name
            }
        }
    }
`

INGEDIENTS_LIST_QUERY = gql`
  {
    ingredients {
      _id
      name
    }
  }
`