@khanacademy/wonder-blocks-data 5.0.1 → 6.0.0

package/src/util/__tests__/ssr-cache.test.js

@@ -1,7 +1,7 @@
 // @flow
 import {Server} from "@khanacademy/wonder-blocks-core";
 import {SsrCache} from "../ssr-cache.js";
-import {ScopedInMemoryCache} from "../scoped-in-memory-cache.js";
+import {SerializableInMemoryCache} from "../serializable-in-memory-cache.js";
 
 describe("../ssr-cache.js", () => {
     afterEach(() => {
@@ -56,7 +56,7 @@ describe("../ssr-cache.js", () => {
 
         it("should throw if the cache is already intialized", () => {
             // Arrange
-            const internalCache = new ScopedInMemoryCache({
+            const internalCache = new SerializableInMemoryCache({
                 MY_KEY: {data: "THE_DATA"},
             });
             const cache = new SsrCache(internalCache);
@@ -95,7 +95,7 @@ describe("../ssr-cache.js", () => {
         describe("when client-side", () => {
             it("should not store the entry in the hydration cache", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
                 const cache = new SsrCache(hydrationCache);
                 const hydrationStoreSpy = jest.spyOn(hydrationCache, "set");
 
@@ -108,8 +108,8 @@ describe("../ssr-cache.js", () => {
 
             it("should not store the entry in the ssrOnly cache", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
-                const ssrOnlyCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
+                const ssrOnlyCache = new SerializableInMemoryCache();
                 const cache = new SsrCache(hydrationCache, ssrOnlyCache);
                 const ssrOnlyStoreSpy = jest.spyOn(ssrOnlyCache, "set");
 
@@ -129,7 +129,7 @@ describe("../ssr-cache.js", () => {
             describe("when hydrate is true", () => {
                 it("should store the entry in the hydration cache", () => {
                     // Arrange
-                    const hydrationCache = new ScopedInMemoryCache();
+                    const hydrationCache = new SerializableInMemoryCache();
                     const cache = new SsrCache(hydrationCache);
                     const hydrationStoreSpy = jest.spyOn(hydrationCache, "set");
 
@@ -148,8 +148,8 @@ describe("../ssr-cache.js", () => {
 
                 it("should not store the entry in the ssrOnly cache", () => {
                     // Arrange
-                    const hydrationCache = new ScopedInMemoryCache();
-                    const ssrOnlyCache = new ScopedInMemoryCache();
+                    const hydrationCache = new SerializableInMemoryCache();
+                    const ssrOnlyCache = new SerializableInMemoryCache();
                     const cache = new SsrCache(hydrationCache, ssrOnlyCache);
                     const ssrOnlyStoreSpy = jest.spyOn(ssrOnlyCache, "set");
 
@@ -164,8 +164,8 @@ describe("../ssr-cache.js", () => {
             describe("when hydrate is false", () => {
                 it("should store the entry in the ssr-only cache", () => {
                     // Arrange
-                    const hydrationCache = new ScopedInMemoryCache();
-                    const ssrOnlyCache = new ScopedInMemoryCache();
+                    const hydrationCache = new SerializableInMemoryCache();
+                    const ssrOnlyCache = new SerializableInMemoryCache();
                     const cache = new SsrCache(hydrationCache, ssrOnlyCache);
                     const ssrOnlyStoreSpy = jest.spyOn(ssrOnlyCache, "set");
 
@@ -184,8 +184,8 @@ describe("../ssr-cache.js", () => {
 
                 it("should not store the entry in the hydration cache", () => {
                     // Arrange
-                    const hydrationCache = new ScopedInMemoryCache();
-                    const ssrOnlyCache = new ScopedInMemoryCache();
+                    const hydrationCache = new SerializableInMemoryCache();
+                    const ssrOnlyCache = new SerializableInMemoryCache();
                     const cache = new SsrCache(hydrationCache, ssrOnlyCache);
                     const hydrationStoreSpy = jest.spyOn(hydrationCache, "set");
 
@@ -203,7 +203,7 @@ describe("../ssr-cache.js", () => {
         describe("when client-side", () => {
             it("should not store the entry in the hydration cache", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
                 const cache = new SsrCache(hydrationCache);
                 const hydrationStoreSpy = jest.spyOn(hydrationCache, "set");
 
@@ -216,8 +216,8 @@ describe("../ssr-cache.js", () => {
 
             it("should not store the entry in the ssrOnly cache", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
-                const ssrOnlyCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
+                const ssrOnlyCache = new SerializableInMemoryCache();
                 const cache = new SsrCache(hydrationCache, ssrOnlyCache);
                 const ssrOnlyStoreSpy = jest.spyOn(ssrOnlyCache, "set");
 
@@ -237,7 +237,7 @@ describe("../ssr-cache.js", () => {
             describe("when hydrate is true", () => {
                 it("should store the entry in the hydration cache", () => {
                     // Arrange
-                    const hydrationCache = new ScopedInMemoryCache();
+                    const hydrationCache = new SerializableInMemoryCache();
                     const cache = new SsrCache(hydrationCache);
                     const hydrationStoreSpy = jest.spyOn(hydrationCache, "set");
 
@@ -256,8 +256,8 @@ describe("../ssr-cache.js", () => {
 
                 it("should not store the entry in the ssrOnly cache", () => {
                     // Arrange
-                    const hydrationCache = new ScopedInMemoryCache();
-                    const ssrOnlyCache = new ScopedInMemoryCache();
+                    const hydrationCache = new SerializableInMemoryCache();
+                    const ssrOnlyCache = new SerializableInMemoryCache();
                     const cache = new SsrCache(hydrationCache, ssrOnlyCache);
                     const ssrOnlyStoreSpy = jest.spyOn(ssrOnlyCache, "set");
 
@@ -272,8 +272,8 @@ describe("../ssr-cache.js", () => {
             describe("when hydrate is false", () => {
                 it("should store the entry in the ssr-only cache", () => {
                     // Arrange
-                    const hydrationCache = new ScopedInMemoryCache();
-                    const ssrOnlyCache = new ScopedInMemoryCache();
+                    const hydrationCache = new SerializableInMemoryCache();
+                    const ssrOnlyCache = new SerializableInMemoryCache();
                     const cache = new SsrCache(hydrationCache, ssrOnlyCache);
                     const ssrOnlyStoreSpy = jest.spyOn(ssrOnlyCache, "set");
 
@@ -292,8 +292,8 @@ describe("../ssr-cache.js", () => {
 
                 it("should not store the entry in the hydration cache", () => {
                     // Arrange
-                    const hydrationCache = new ScopedInMemoryCache();
-                    const ssrOnlyCache = new ScopedInMemoryCache();
+                    const hydrationCache = new SerializableInMemoryCache();
+                    const ssrOnlyCache = new SerializableInMemoryCache();
                     const cache = new SsrCache(hydrationCache, ssrOnlyCache);
                     const hydrationStoreSpy = jest.spyOn(hydrationCache, "set");
 
@@ -315,7 +315,7 @@ describe("../ssr-cache.js", () => {
 
             it("should return null if not in the hydration cache", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
                 jest.spyOn(hydrationCache, "get").mockReturnValue(null);
                 const cache = new SsrCache(hydrationCache);
 
@@ -328,7 +328,7 @@ describe("../ssr-cache.js", () => {
 
             it("should return the cached entry if in the hydration cache", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
                 jest.spyOn(hydrationCache, "get").mockReturnValue({
                     data: "data!",
                 });
@@ -349,8 +349,8 @@ describe("../ssr-cache.js", () => {
 
             it("should return null in any cache", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
-                const ssrOnlyCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
+                const ssrOnlyCache = new SerializableInMemoryCache();
                 const cache = new SsrCache(hydrationCache, ssrOnlyCache);
 
                 // Act
@@ -362,7 +362,7 @@ describe("../ssr-cache.js", () => {
 
             it("should return the cached entry if in the hydration cache", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
                 jest.spyOn(hydrationCache, "get").mockReturnValue({
                     data: "data!",
                 });
@@ -377,8 +377,8 @@ describe("../ssr-cache.js", () => {
 
             it("should return the cached entry if in the ssr-only cache", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
-                const ssrOnlyCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
+                const ssrOnlyCache = new SerializableInMemoryCache();
                 jest.spyOn(ssrOnlyCache, "get").mockReturnValue({
                     data: "data!",
                 });
@@ -396,8 +396,8 @@ describe("../ssr-cache.js", () => {
     describe("#remove", () => {
         it("should return false if nothing was removed", () => {
             // Arrange
-            const hydrationCache = new ScopedInMemoryCache();
-            const ssrOnlycache = new ScopedInMemoryCache();
+            const hydrationCache = new SerializableInMemoryCache();
+            const ssrOnlycache = new SerializableInMemoryCache();
             jest.spyOn(hydrationCache, "purge").mockReturnValue(false);
             jest.spyOn(ssrOnlycache, "purge").mockReturnValue(false);
             const cache = new SsrCache(hydrationCache, ssrOnlycache);
@@ -411,7 +411,7 @@ describe("../ssr-cache.js", () => {
 
         it("should return true if something was removed from hydration cache", () => {
             // Arrange
-            const hydrationCache = new ScopedInMemoryCache();
+            const hydrationCache = new SerializableInMemoryCache();
             jest.spyOn(hydrationCache, "purge").mockReturnValue(true);
             const cache = new SsrCache(hydrationCache);
 
@@ -429,8 +429,8 @@ describe("../ssr-cache.js", () => {
 
             it("should return true if something was removed from ssr-only cache", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
-                const ssrOnlyCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
+                const ssrOnlyCache = new SerializableInMemoryCache();
                 jest.spyOn(ssrOnlyCache, "purge").mockReturnValue(true);
                 const cache = new SsrCache(hydrationCache, ssrOnlyCache);
 
@@ -446,7 +446,7 @@ describe("../ssr-cache.js", () => {
     describe("#cloneHydratableData", () => {
         it("should clone the hydration cache", () => {
             // Arrange
-            const hydrationCache = new ScopedInMemoryCache();
+            const hydrationCache = new SerializableInMemoryCache();
             const cloneSpy = jest
                 .spyOn(hydrationCache, "clone")
                 .mockReturnValue({
@@ -475,7 +475,7 @@ describe("../ssr-cache.js", () => {
 
             it("should remove all entries from the hydration cache when client-side without predicate", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
                 const purgeAllSpy = jest.spyOn(hydrationCache, "purgeAll");
                 const cache = new SsrCache(hydrationCache);
 
@@ -488,11 +488,11 @@ describe("../ssr-cache.js", () => {
 
             it("should pass a predicate to hydration cache purge if a predicate is passed", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
                 const purgeAllSpy = jest.spyOn(hydrationCache, "purgeAll");
                 const cache = new SsrCache(
                     hydrationCache,
-                    new ScopedInMemoryCache(),
+                    new SerializableInMemoryCache(),
                 );
 
                 // Act
@@ -504,7 +504,7 @@ describe("../ssr-cache.js", () => {
 
             it("should pass a predicate to the hydration cache that calls the predicate it was given", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache({
+                const hydrationCache = new SerializableInMemoryCache({
                     default: {
                         KEY1: {
                             data: "DATA",
@@ -513,7 +513,7 @@ describe("../ssr-cache.js", () => {
                 });
                 const cache = new SsrCache(
                     hydrationCache,
-                    new ScopedInMemoryCache(),
+                    new SerializableInMemoryCache(),
                 );
                 const predicate = jest.fn().mockReturnValue(false);
 
@@ -532,14 +532,14 @@ describe("../ssr-cache.js", () => {
 
             it("should remove all entries from hydration cache when server-side without predicate", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
                 const hydrationPurgeAllSpy = jest.spyOn(
                     hydrationCache,
                     "purgeAll",
                 );
                 const cache = new SsrCache(
                     hydrationCache,
-                    new ScopedInMemoryCache(),
+                    new SerializableInMemoryCache(),
                 );
 
                 // Act
@@ -551,10 +551,10 @@ describe("../ssr-cache.js", () => {
 
             it("should remove all entries from ssr cache when server-side without predicate", () => {
                 // Arrange
-                const ssrOnlyCache = new ScopedInMemoryCache();
+                const ssrOnlyCache = new SerializableInMemoryCache();
                 const ssrPurgeAllSpy = jest.spyOn(ssrOnlyCache, "purgeAll");
                 const cache = new SsrCache(
-                    new ScopedInMemoryCache(),
+                    new SerializableInMemoryCache(),
                     ssrOnlyCache,
                 );
 
@@ -567,11 +567,11 @@ describe("../ssr-cache.js", () => {
 
             it("should pass a predicate to hydration cache purge if a predicate is passed", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
                 const purgeAllSpy = jest.spyOn(hydrationCache, "purgeAll");
                 const cache = new SsrCache(
                     hydrationCache,
-                    new ScopedInMemoryCache(),
+                    new SerializableInMemoryCache(),
                 );
 
                 // Act
@@ -583,10 +583,10 @@ describe("../ssr-cache.js", () => {
 
             it("should pass a predicate to srr cache purge if a predicate is passed", () => {
                 // Arrange
-                const ssrOnlyCache = new ScopedInMemoryCache();
+                const ssrOnlyCache = new SerializableInMemoryCache();
                 const purgeAllSpy = jest.spyOn(ssrOnlyCache, "purgeAll");
                 const cache = new SsrCache(
-                    new ScopedInMemoryCache(),
+                    new SerializableInMemoryCache(),
                     ssrOnlyCache,
                 );
 
@@ -599,10 +599,10 @@ describe("../ssr-cache.js", () => {
 
             it("should pass a predicate to the hydration cache that calls the predicate it was given", () => {
                 // Arrange
-                const hydrationCache = new ScopedInMemoryCache();
+                const hydrationCache = new SerializableInMemoryCache();
                 const cache = new SsrCache(
                     hydrationCache,
-                    new ScopedInMemoryCache(),
+                    new SerializableInMemoryCache(),
                 );
                 cache.cacheData("KEY1", "DATA", true);
                 const predicate = jest.fn().mockReturnValue(false);
@@ -616,9 +616,9 @@ describe("../ssr-cache.js", () => {
 
             it("should pass a predicate to the ssr cache that calls the predicate it was given", () => {
                 // Arrange
-                const ssrOnlyCache = new ScopedInMemoryCache();
+                const ssrOnlyCache = new SerializableInMemoryCache();
                 const cache = new SsrCache(
-                    new ScopedInMemoryCache(),
+                    new SerializableInMemoryCache(),
                     ssrOnlyCache,
                 );
                 cache.cacheData(

package/src/util/abort-error.js

@@ -0,0 +1,15 @@
+// @flow
+
+/**
+ * Simple implementation to represent aborting.
+ *
+ * Other frameworks may provide this too, so we won't be sharing this with
+ * the outside world. It's just a utility for test and internal use whenever
+ * we need to represent the concept of aborted things.
+ */
+export class AbortError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "AbortError";
+    }
+}

package/src/util/data-error.js

@@ -0,0 +1,58 @@
+// @flow
+import {KindError} from "@khanacademy/wonder-stuff-core";
+import type {ErrorOptions} from "./types.js";
+
+/**
+ * Error kinds for DataError.
+ */
+export const DataErrors = Object.freeze({
+    /**
+     * The kind of error is not known.
+     */
+    Unknown: "Unknown",
+
+    /**
+     * The error is internal to the executing code.
+     */
+    Internal: "Internal",
+
+    /**
+     * There was a problem with the provided input.
+     */
+    InvalidInput: "InvalidInput",
+
+    /**
+     * A network error occurred.
+     */
+    Network: "Network",
+
+    /**
+     * Response could not be parsed.
+     */
+    Parse: "Parse",
+
+    /**
+     * An error that occurred during SSR and was hydrated from cache
+     */
+    Hydrated: "Hydrated",
+});
+
+/**
+ * An error from the Wonder Blocks Data API.
+ *
+ * Errors of this type will have names of the format:
+ *     `${kind}DataError`
+ */
+export class DataError extends KindError {
+    constructor(
+        message: string,
+        kind: $Values<typeof DataErrors>,
+        {metadata, cause}: ErrorOptions = ({}: $Shape<ErrorOptions>),
+    ) {
+        super(message, kind, {
+            metadata,
+            cause,
+            name: "Data",
+        });
+    }
+}

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

@@ -1,4 +1,5 @@
 // @flow
+import {DataError, DataErrors} from "./data-error.js";
 import {GqlError, GqlErrors} from "./gql-error.js";
 
 /**
@@ -14,7 +15,7 @@ export const getGqlDataFromResponse = async <TData>(
     try {
         result = JSON.parse(bodyText);
     } catch (e) {
-        throw new GqlError("Failed to parse response", GqlErrors.Parse, {
+        throw new DataError("Failed to parse response", DataErrors.Parse, {
             metadata: {
                 statusCode: response.status,
                 bodyText,
@@ -25,7 +26,7 @@ export const getGqlDataFromResponse = async <TData>(
 
     // Check for a bad status code.
     if (response.status >= 300) {
-        throw new GqlError("Response unsuccessful", GqlErrors.Network, {
+        throw new DataError("Response unsuccessful", DataErrors.Network, {
             metadata: {
                 statusCode: response.status,
                 result,

package/src/util/gql-error.js

@@ -1,36 +1,44 @@
 // @flow
-import {KindError, Errors} from "@khanacademy/wonder-stuff-core";
-import type {Metadata} from "@khanacademy/wonder-stuff-core";
+import {KindError} from "@khanacademy/wonder-stuff-core";
 
-type GqlErrorOptions = {|
-    metadata?: ?Metadata,
-    cause?: ?Error,
-|};
+import type {ErrorOptions} from "./types.js";
 
 /**
  * Error kinds for GqlError.
  */
 export const GqlErrors = Object.freeze({
-    ...Errors,
-    Network: "Network",
-    Parse: "Parse",
+    /**
+     * An internal framework error.
+     */
+    Internal: "Internal",
+
+    /**
+     * Response does not have the correct structure for a GraphQL response.
+     */
     BadResponse: "BadResponse",
+
+    /**
+     * A valid GraphQL result with errors field in the payload.
+     */
     ErrorResult: "ErrorResult",
 });
 
 /**
  * An error from the GQL API.
+ *
+ * Errors of this type will have names of the format:
+ *     `${kind}GqlError`
  */
 export class GqlError extends KindError {
     constructor(
         message: string,
         kind: $Values<typeof GqlErrors>,
-        {metadata, cause}: GqlErrorOptions = ({}: $Shape<GqlErrorOptions>),
+        {metadata, cause}: ErrorOptions = ({}: $Shape<ErrorOptions>),
     ) {
         super(message, kind, {
             metadata,
             cause,
-            prefix: "Gql",
+            name: "Gql",
         });
     }
 }

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

@@ -0,0 +1,34 @@
+// @flow
+import type {GqlContext} from "./gql-types.js";
+
+/**
+ * Construct a complete GqlContext from current defaults and a partial context.
+ *
+ * Values in the partial context that are `undefined` will be ignored.
+ * Values in the partial context that are `null` will be deleted.
+ */
+export const mergeGqlContext = <TContext: GqlContext>(
+    defaultContext: TContext,
+    overrides: Partial<TContext>,
+): TContext => {
+    // Let's merge the partial context default context. We deliberately
+    // don't spread because spreading would overwrite default context
+    // values with undefined or null if the partial context includes a value
+    // explicitly set to undefined or null.
+    return Object.keys(overrides).reduce(
+        (acc, key) => {
+            // Undefined values are ignored.
+            if (overrides[key] !== undefined) {
+                if (overrides[key] === null) {
+                    // Null indicates we delete this context value.
+                    delete acc[key];
+                } else {
+                    // Otherwise, we set it.
+                    acc[key] = overrides[key];
+                }
+            }
+            return acc;
+        },
+        {...defaultContext},
+    );
+};