@oobleck/fluid-backend/src/services/backend.ts

Fluid Framework backend for nteract RTC

import { DocumentNode, execute, ExecutionResult, GraphQLSchema, subscribe } from "graphql";
import { Maybe } from "graphql/jsutils/Maybe";
import { makeExecutableSchema } from "@graphql-tools/schema";
import { mergeTypeDefs } from "@graphql-tools/merge";
import { ExecuteError, ExecuteResult, ICollaborationBackend } from "../types";
import { ResolverContext } from "./context";
import { NotebookResolvers } from "./resolvers";

import queriesSchema from "../schema/gql/queries.gql";
import mutationsSchema from "../schema/gql/mutations.gql";
import subscriptionsSchema from "../schema/gql/subscriptions.gql";

export class FluidBackend implements ICollaborationBackend {
  private readonly schema: GraphQLSchema;
  private readonly context = new ResolverContext();

  constructor() {
    const typeDefs = mergeTypeDefs([queriesSchema, mutationsSchema, subscriptionsSchema]);
    this.schema = makeExecutableSchema({ typeDefs, resolvers: NotebookResolvers });
  }

  dispose() {
    this.context.dispose();
  }

  async execute(document: DocumentNode, variableValues?: Maybe<{ [key: string]: unknown }>): Promise<ExecuteResult> {
    const valueOrPromise = execute({ schema: this.schema, document, variableValues, contextValue: this.context });
    const result = await Promise.resolve(valueOrPromise);
    if (result.errors) {
      throw new ExecuteError(result.errors);
    }
    return result.data ?? {};
  }

  async subscribe(
    document: DocumentNode,
    variableValues?: Maybe<{ [key: string]: unknown }>
  ): Promise<AsyncIterableIterator<ExecutionResult>> {
    const result = subscribe({
      schema: this.schema,
      document,
      variableValues,
      contextValue: this.context
    }) as any;
    return result;
  }
}