@khanacademy/wonder-blocks-data 3.0.1 → 3.1.0

package/src/util/get-gql-data-from-response.js

@@ -0,0 +1,69 @@
+// @flow
+import {GqlError, GqlErrors} from "./gql-error.js";
+
+/**
+ * Validate a GQL operation response and extract the data.
+ */
+export const getGqlDataFromResponse = async <TData>(
+    response: Response,
+): Promise<TData> => {
+    // Get the response as text, that way we can use the text in error
+    // messaging, should our parsing fail.
+    const bodyText = await response.text();
+    let result;
+    try {
+        result = JSON.parse(bodyText);
+    } catch (e) {
+        throw new GqlError("Failed to parse response", GqlErrors.Parse, {
+            metadata: {
+                statusCode: response.status,
+                bodyText,
+            },
+            cause: e,
+        });
+    }
+
+    // Check for a bad status code.
+    if (response.status >= 300) {
+        throw new GqlError("Response unsuccessful", GqlErrors.Network, {
+            metadata: {
+                statusCode: response.status,
+                result,
+            },
+        });
+    }
+
+    // Check that we have a valid result payload.
+    if (
+        // Flow shouldn't be warning about this.
+        // $FlowIgnore[method-unbinding]
+        !Object.prototype.hasOwnProperty.call(result, "data") &&
+        // Flow shouldn't be warning about this.
+        // $FlowIgnore[method-unbinding]
+        !Object.prototype.hasOwnProperty.call(result, "errors")
+    ) {
+        throw new GqlError("Server response missing", GqlErrors.BadResponse, {
+            metadata: {
+                statusCode: response.status,
+                result,
+            },
+        });
+    }
+
+    // If the response payload has errors, throw an error.
+    if (
+        result.errors != null &&
+        Array.isArray(result.errors) &&
+        result.errors.length > 0
+    ) {
+        throw new GqlError("GraphQL errors", GqlErrors.ErrorResult, {
+            metadata: {
+                statusCode: response.status,
+                result,
+            },
+        });
+    }
+
+    // We got here, so return the data.
+    return result.data;
+};

package/src/util/gql-error.js

@@ -0,0 +1,36 @@
+// @flow
+import {KindError, Errors} from "@khanacademy/wonder-stuff-core";
+import type {Metadata} from "@khanacademy/wonder-stuff-core";
+
+type GqlErrorOptions = {|
+    metadata?: ?Metadata,
+    cause?: ?Error,
+|};
+
+/**
+ * Error kinds for GqlError.
+ */
+export const GqlErrors = Object.freeze({
+    ...Errors,
+    Network: "Network",
+    Parse: "Parse",
+    BadResponse: "BadResponse",
+    ErrorResult: "ErrorResult",
+});
+
+/**
+ * An error from the GQL API.
+ */
+export class GqlError extends KindError {
+    constructor(
+        message: string,
+        kind: $Values<typeof GqlErrors>,
+        {metadata, cause}: GqlErrorOptions = ({}: $Shape<GqlErrorOptions>),
+    ) {
+        super(message, kind, {
+            metadata,
+            cause,
+            prefix: "Gql",
+        });
+    }
+}

package/src/util/gql-router-context.js

@@ -0,0 +1,6 @@
+// @flow
+import * as React from "react";
+import type {GqlRouterConfiguration} from "./gql-types.js";
+
+export const GqlRouterContext: React.Context<?GqlRouterConfiguration<any>> =
+    React.createContext<?GqlRouterConfiguration<any>>(null);

package/src/util/gql-types.js

@@ -0,0 +1,60 @@
+// @flow
+/**
+ * Operation types.
+ */
+export type GqlOperationType = "mutation" | "query";
+
+/**
+ * A GraphQL operation.
+ */
+export type GqlOperation<
+    TType: GqlOperationType,
+    // TData is not used to define a field on this type, but it is used
+    // to ensure that calls using this operation will properly return the
+    // correct data type.
+    // eslint-disable-next-line no-unused-vars
+    TData,
+    // TVariables is not used to define a field on this type, but it is used
+    // to ensure that calls using this operation will properly consume the
+    // correct variables type.
+    // eslint-disable-next-line no-unused-vars
+    TVariables: {...} = Empty,
+> = {
+    type: TType,
+    id: string,
+    // We allow other things here to be passed along to the fetch function.
+    // For example, we might want to pass the full query/mutation definition
+    // as a string here to allow that to be sent to an Apollo server that
+    // expects it. This is a courtesy to calling code; these additional
+    // values are ignored by WB Data, and passed through as-is.
+    ...
+};
+
+export type GqlContext = {|
+    [key: string]: string,
+|};
+
+/**
+ * Functions that make fetches of GQL operations.
+ */
+export type FetchFn<TType, TData, TVariables: {...}, TContext: GqlContext> = (
+    operation: GqlOperation<TType, TData, TVariables>,
+    variables: ?TVariables,
+    context: TContext,
+) => Promise<Response>;
+
+/**
+ * The configuration stored in the GqlRouterContext context.
+ */
+export type GqlRouterConfiguration<TContext: GqlContext> = {|
+    fetch: FetchFn<any, any, any, any>,
+    defaultContext: TContext,
+|};
+
+/**
+ * Options for configuring a GQL fetch.
+ */
+export type GqlFetchOptions<TVariables: {...}, TContext: GqlContext> = {|
+    variables?: TVariables,
+    context?: Partial<TContext>,
+|};