GraphQLGrant.ts

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

import {
  connectionFromArray,
  connectionArgs,
  ConnectionArguments
} from "graphql-relay";

import { Grant, Client, User } from "../model";
import { Context } from "../Context";
import { GraphQLClient } from "./GraphQLClient";
import { GraphQLUser } from "./GraphQLUser";
import { GraphQLAuthorizationConnection } from "./GraphQLAuthorizationConnection";
import { filter } from "../util/filter";

export const GraphQLGrant: GraphQLObjectType<
  Grant,
  Context
> = new GraphQLObjectType<Grant, Context>({
  name: "Grant",
  interfaces: () => [],
  fields: () => ({
    id: { type: new GraphQLNonNull(GraphQLID) },
    enabled: {
      type: new GraphQLNonNull(GraphQLBoolean)
    },
    user: {
      type: GraphQLUser,
      async resolve(
        grant,
        args,
        { realm, authorization: a, tx }: Context
      ): Promise<null | User> {
        if (!a) return null;
        const user = await grant.user(tx);
        return user.isAccessibleBy(realm, a, tx) ? user : null;
      }
    },
    client: {
      type: GraphQLClient,
      async resolve(
        grant,
        args,
        { realm, authorization: a, tx }: Context
      ): Promise<null | Client> {
        if (!a) return null;
        const client = await grant.client(tx);
        return client.isAccessibleBy(realm, a, tx) ? client : null;
      }
    },
    secrets: {
      type: new GraphQLList(GraphQLString),
      async resolve(
        grant,
        args,
        { realm, authorization: a, tx }: Context
      ): Promise<null | string[]> {
        return a && (await grant.isAccessibleBy(realm, a, tx, "read.secrets"))
          ? [...grant.secrets]
          : null;
      }
    },
    codes: {
      type: new GraphQLList(GraphQLString),
      async resolve(
        grant,
        args,
        { realm, authorization: a, tx }: Context
      ): Promise<null | string[]> {
        return a && (await grant.isAccessibleBy(realm, a, tx, "read.secrets"))
          ? [...grant.codes]
          : null;
      }
    },
    scopes: {
      type: new GraphQLList(GraphQLString),
      async resolve(
        grant,
        args,
        { realm, authorization: q, tx }: Context
      ): Promise<null | string[]> {
        return q && (await grant.isAccessibleBy(realm, q, tx, "read.scopes"))
          ? grant.scopes
          : null;
      }
    },
    authorizations: {
      type: GraphQLAuthorizationConnection,
      args: connectionArgs,
      async resolve(
        grant,
        args: ConnectionArguments,
        { realm, authorization: a, tx }: Context
      ) {
        return a
          ? connectionFromArray(
              await filter(await grant.authorizations(tx), authorization =>
                authorization.isAccessibleBy(realm, a, tx)
              ),
              args
            )
          : null;
      }
    }
  })
});