@apollo/client/core#gql TypeScript Examples

async function getLabelByName(name: string) {
    const info = await client.query({
        query: gql`
          query GetLabel($name: String!) {
            repository(name: "DefinitelyTyped", owner: "DefinitelyTyped") {
              id
              name
              labels(query: $name, first: 1) {
                nodes {
                  id
                  name
                }
              }
            }
          }`,
        variables: { name },
        fetchPolicy: "no-cache",
    });

    const label: { id: string, name: string } | undefined =  info.data.repository.labels.nodes[0];
    return { repoID: info.data.repository.id, label };
}

PERMISSIONS_QUERY = gql`query {
  permissions {
    entities {
      target
      value
    },
    entityAttributes {
      target
      value
    }
    specifics {
      target
      value
    }
    ${process.env.REACT_APP_ENABLE_UI_PERMISSIONS === "true" 
      ? `
        menus {
          target
          value
        }
        screens {
          target
          value
        }`
      : ""
    }
  }
}`

async function getVaultTokens() {
  const ids = [];
  const url = `https://api.thegraph.com/subgraphs/name/nftx-project/nftx-v2`;
  const query = `
    query {
      vault(id:"0x87931e7ad81914e7898d07c68f145fc0a553d8fb") {
        holdings (first: 1000) {
          tokenId
        }
      }
    }
  `
  const client = new ApolloClient({
    uri: url,
    cache: new InMemoryCache()
  });
  try {
    const response = await client.query({
      query: gql(query)
    })
    for (const wiz of response.data.vault.holdings) {
      ids.push(wiz.tokenId);
    }
  } catch(error) {
    console.log(error);
  }
  checkVaultIds(ids);
}

COMMIT_CHANGES = gql`
  mutation commit($message: String!, $appId: String!) {
    commit(data: { message: $message, app: { connect: { id: $appId } } }) {
      id
      createdAt
      userId
      message
      builds {
        id
      }
    }
  }
`

testCases = [
  {
    id: 'getPools',
    query: gql`
      query {
        pools {
          tokens {
            id
          }
          id
        }
      }
    `,
  },
]

async getConnectedAccounts(page: number): Promise<Accounts> {
    const { apiService } = this.services;

    const { result } = await apiService.query<{
      result: Accounts;
    }>(
      gql`
        query($chainId: Int, $page: Int) {
          result: accounts(chainId: $chainId, page: $page) {
            items {
              address
              type
              state
              store
              createdAt
              updatedAt
            }
            currentPage
            nextPage
          }
        }
      `,
      {
        variables: {
          page: page || 1,
        },
        models: {
          result: Accounts,
        },
      },
    );

    return result;
  }

ADMIN_PROFILE_FRAGMENT = gql`
  fragment AdminProfile on Profile {
    id
    email
    username
    language
    firstName
    lastName
    roles
    created
    lastModified
  }
`

protected updateCollectionField(typename: string, dataId: string) {
    // Since colletion support is still experimental, only record entities in collections if enabled
    if (!this.enableCollections) {
      return;
    }

    const collectionEntityId = collectionEntityIdForType(typename);
    const collectionFieldExists = !!this.readField<Record<string, any[]>>('id', makeReference(collectionEntityId));

    // If the collection field for the type does not exist in the cache, then initialize it as
    // an empty array.
    if (!collectionFieldExists) {
      this.writeFragment({
        id: collectionEntityId,
        fragment: gql`
          fragment InitializeCollectionEntity on CacheExtensionsCollectionEntity {
            data
            id
          }
        `,
        data: {
          __typename: cacheExtensionsCollectionTypename,
          id: typename,
          data: [],
        },
      });
    }

    // If the entity does not already exist in the cache, add it to the collection field policy for its type
    if (!this.entityTypeMap.readEntityById(dataId)) {
      this.modify({
        broadcast: false,
        id: collectionEntityId,
        fields: {
          data: (existing, { canRead }) => {
            return [
              ...existing.filter((ref: Reference) => canRead(ref)),
              makeReference(dataId),
            ];
          }
        }
      });
    }
  }

/**
   * Get OS sales for specific collection
   */
  public async getSales(collection: CollectionConfig): Promise<Sale[]> {
    const timestamp =
      Math.floor(Date.now() / 1000) -
      Number(this.configService.bot.salesLookbackSeconds);
    const NFTX_GET_REDEEM = gql`
    {
      redeems(
        first: 100,
        where: { date_gt: "${timestamp}", vault: "${collection.nftxVaultContract}" },
        orderBy: date,
        orderDirection: desc
      ) {
        id
        zapAction {
          ethAmount
          id
        }
        vault {
          id
          vaultId
          token {
            symbol
          }
          asset {
            id
          }
        }
        user {
          id
        }
        date
        nftIds
        specificIds
        randomCount
        targetCount
        feeReceipt {
          transfers {
            amount
          }
          date
        }
      }
    }`;

    let sales: Array<Sale> = [];
    try {
      this._logger.log(`Checking for sales${collection.openSeaSlug}/NFTx`);
      const response = await this._nftxClient.query({
        query: NFTX_GET_REDEEM,
      });
      if (response.error) {
        this._logger.debug(response.error);
      }
      if (response.data.redeems.length) {
        sales = await this.createSales(response.data.redeems, collection);
        this._logger.log(
          `Found ${sales.length} sales ${collection.openSeaSlug}/NFTx`,
        );
      } else {
        this._logger.log(`No sales ${collection.openSeaSlug}/NFTx`);
      }
    } catch (error) {
      this._logger.error(error);
    } finally {
      return sales.reverse();
    }
  }

LOGIN = gql`
  mutation login($username: String!, $password: String!) {
    login(credentials: { username: $username, password: $password }) {
      username
      roles
    }
  }
`

async syncAccount(): Promise<Account> {
    const { apiService } = this.services;

    switch (this.account.type) {
      case AccountTypes.Key: {
        const { account } = await apiService.mutate<{
          account: Account;
        }>(
          gql`
            mutation($chainId: Int) {
              account: syncAccount(chainId: $chainId) {
                address
                type
                state
                store
                createdAt
                updatedAt
              }
            }
          `,
          {
            models: {
              account: Account,
            },
          },
        );

        this.account$.next(account);
        break;
      }

      case AccountTypes.Contract: {
        const {
          accountMember: { account, ...accountMember },
        } = await apiService.mutate<{
          accountMember: AccountMember;
        }>(
          gql`
            mutation($chainId: Int, $account: String!) {
              accountMember: syncAccountMember(chainId: $chainId, account: $account) {
                account {
                  address
                  type
                  state
                  store
                  createdAt
                  updatedAt
                }
                type
                state
                store
                createdAt
                updatedAt
              }
            }
          `,
          {
            variables: {
              account: this.accountAddress,
            },
            models: {
              accountMember: AccountMember,
            },
          },
        );

        this.account$.next(account);
        this.accountMember$.next(accountMember);
        break;
      }
    }

    return this.account;
  }