@khanacademy/wonder-blocks-data 10.1.0 → 10.1.1

package/src/__docs__/types.gql-operation-type.stories.mdx

@@ -1,24 +0,0 @@
-import {Meta} from "@storybook/addon-docs";
-
-<Meta
-    title="Data / Types / GqlOperationType"
-    parameters={{
-        chromatic: {
-            disableSnapshot: true,
-        },
-    }}
-/>
-
-# GqlOperationType
-
-```ts
-type GqlOperationType = "mutation" | "query";
-```
-
-Unlike some GraphQL clients, the Wonder Blocks Data GraphQL support avoids requiring the full GraphQL document node at runtime. This allows the client to be lighter weight and introduces the option for calling code to perform some GraphQL request optimizations at build time, such as formatting the document node as a string and therefore not requiring additional dependencies at runtime.
-
-In order to allow consumers of our GraphQL support to include some validation of the GraphQL document node at runtime (such as ensuring that mutations are not performed in unsupported scenarios), we the type of the operation is included in the operation definition.
-
-This type represents the valid values for that field.
-
-See the section on [GraphQL](/docs/data-graphql--page) for more information.

package/src/__docs__/types.gql-operation.stories.mdx

@@ -1,67 +0,0 @@
-import {Meta} from "@storybook/addon-docs";
-
-<Meta
-    title="Data / Types / GqlOperation<>"
-    parameters={{
-        chromatic: {
-            disableSnapshot: true,
-        },
-    }}
-/>
-
-# GqlOperation&lt;&gt;
-
-```ts
-type GqlOperation<
-    TData,
-    TVariables: {...} = Empty,
-> = {
-    type: GqlOperationType,
-    id: string,
-    [key: string]: mixed,
-    ...
-};
-```
-
-The `GqlOperation<>` type provides the Wonder Blocks Data definition of a GraphQL query or mutation. It has two required fields:
-
- * `type`: The type of operation. It can be either `"query"` or `"mutation"`.
- * `id`: The unique identifier of the operation.
-
-Unlike some GraphQL clients, the definition of the operation (the document node, for example) is not required by the Wonder Blocks Data implementation. If a specific use requires that information, the calling code is able to provide it.
-
-Consider the following GraphQL query (using `graphql-tag`):
-
-```ts
-const MyQuery = gql`
-    query myQuery {
-        user {
-            id
-            name
-        }
-    }
-`;
-```
-
-Rather than using the full `DocumentNode` at runtime, one could envisage a build step that converts it to a `GqlOperation<>` at compile time by parsing the `DocumentNode` to determine the operation type and extract the name of the operation. If the actual definition is needed for sending to the server in the request, this can be obtained from `graphql/language/printer`. This would then reduce the dependencies needed to perform GraphQL operations at runtime.
-
-The resulting `GqlOperation<>` would look like this:
-
-```ts
-{
-    type: "query",
-    id: "myQuery",
-}
-```
-
-Or, if say, the query definition were needed (for example, Apollo will send requests with the `query` field):
-
-```ts
-{
-    type: "query",
-    id: "myQuery",
-    query: "query myQuery { user { id name } }",
-}
-```
-
-See the section on [GraphQL](/docs/data-graphql--page) for more information.

package/src/__docs__/types.raw-scoped-cache.stories.mdx

@@ -1,27 +0,0 @@
-import {Meta} from "@storybook/addon-docs";
-
-<Meta
-    title="Data / Types / RawScopedCache"
-    parameters={{
-        chromatic: {
-            disableSnapshot: true,
-        },
-    }}
-/>
-
-# RawScopedCache
-
-```ts
-type RawScopedCache = {
-    [scope: string]: {
-        [id: string]: ValidCacheData,
-        ...
-    },
-    ...
-};
-
-```
-
-`RawScopedCache` describes a cache that has distinct scoped sections in its raw object form. This is the representation of the caches used internally by Wonder Blocks Data to support the scoping of requests when using hooks such as [`useSharedCache`](/docs/data-exports-use-shared-cache--page), [`useCachedEffect`](/docs/data-exports-use-cached-effect--page), and [`useHydratableEffect`](/docs/data-exports-use-hydratable-effect--page).
-
-See the section on [server-side rendering](/docs/data-server-side-rendering-and-hydration--page) for more information.

package/src/__docs__/types.response-cache.stories.mdx

@@ -1,33 +0,0 @@
-import {Meta} from "@storybook/addon-docs";
-
-<Meta
-    title="Data / Types / ResponseCache"
-    parameters={{
-        chromatic: {
-            disableSnapshot: true,
-        },
-    }}
-/>
-
-# ResponseCache
-
-```ts
-type ResponseCache = {
-    [key: string]: CachedResponse<any>,
-    ...
-};
-```
-
-`ResponseCache` describes the serialized cache that is used to hydrate responses. An example of a valid `ResponseCache` instance is shown below. Generally, you would not generate this object directly, but rather use the returned data from [`fetchTrackedRequests`](/docs/data-exports-fetchtrackedrequests--page).
-
-```ts
-const responseCache: ResponseCache = {
-    DATA_ID_1: {error: "It go 💥boom 😢"},
-    DATA_ID_2: {data: ["array", "of", "data"]},
-    DATA_ID_3: {data: {some: "data"}},
-};
-```
-
-In this example, the cache contains data retrieved for three different requests.
-
-Each entry in the cache is of type [`CachedResponse`](/docs/data-types-cachedresponse--page). See the section on [server-side rendering](/docs/data-server-side-rendering-and-hydration--page) for more information.

package/src/__docs__/types.result.stories.mdx

@@ -1,39 +0,0 @@
-import {Meta} from "@storybook/addon-docs";
-
-<Meta
-    title="Data / Types / Result<>"
-    parameters={{
-        chromatic: {
-            disableSnapshot: true,
-        },
-    }}
-/>
-
-# Result&lt;&gt;
-
-```ts
-type Result<TData: ValidCacheData> =
-    | {|
-          status: "loading",
-      |}
-    | {|
-          status: "success",
-          data: TData,
-      |}
-    | {|
-          status: "error",
-          error: Error,
-      |}
-    | {|
-          status: "aborted",
-      |};
-```
-
-The `Result<>` type is used to describe the result of an asynchronous operation. It is the primary type used by hooks and components in Wonder Blocks Data to convey the status of asynchronous tasks.
-
-There are four states represented by the `Result<>` type:
-
- * `loading`: The operation is in pending.
- * `success`: The operation completed successfully.
- * `error`: The operation failed.
- * `aborted`: The operation was aborted.

package/src/__docs__/types.scoped-cache.stories.mdx

@@ -1,114 +0,0 @@
-import {Meta} from "@storybook/addon-docs";
-
-<Meta
-    title="Data / Types / ScopedCache"
-    parameters={{
-        chromatic: {
-            disableSnapshot: true,
-        },
-    }}
-/>
-
-# ScopedCache
-
-```ts
-interface ScopedCache {
-    set(scope: string, id: string, value: ValidCacheData): void;
-
-    /**
-     * Retrieve a value from the cache.
-     */
-    get(scope: string, id: string): ?ValidCacheData;
-
-    /**
-     * Purge an item from the cache.
-     */
-    purge(scope: string, id: string): void;
-
-    /**
-     * Purge a scope of items that match the given predicate.
-     *
-     * If the predicate is omitted, then all items in the scope are purged.
-     */
-    purgeScope(
-        scope: string,
-        predicate?: (id: string, value: ValidCacheData) => boolean,
-    ): void;
-
-    /**
-     * Purge all items from the cache that match the given predicate.
-     *
-     * If the predicate is omitted, then all items in the cache are purged.
-     */
-    purgeAll(
-        predicate?: (
-            scope: string,
-            id: string,
-            value: ValidCacheData,
-        ) => boolean,
-    ): void;
-}
-```
-
-This interface defines how to interact with a scoped cache, such as [`ScopedInMemoryCache`](/docs/data-exports-scopedinmemorycache--page).
-
-## set()
-
-```ts
-set(
-    scope: string,
-    id: string,
-    value: TValue,
-): void;
-```
-
-Sets a value in the cache within a given scope.
-
-### Throws
-
-| Error Type | Error Name | Reason |
-| ------ | ------ | ------ |
-| [`DataError`](/docs/data-exports-dataerror--page) | `InvalidInputDataError` | `id` and `scope` must be non-empty strings |
-| [`DataError`](/docs/data-exports-dataerror--page) | `InvalidInputDataError` | `value` must be a non-function value |
-
-## get()
-
-```ts
-get(scope: string, id: string): ?ValidCacheData;
-```
-
-Gets a value from the cache. If a value with the given identifier (`id`) is not found within the given scope (`scope`) of the cache, `null` is returned.
-
-## purge()
-
-```ts
-purge(scope: string, id: string): void;
-```
-
-Purges the value from the cache. If a value with the given identifier (`id`) is not found within the given scope (`scope`) of the cache, nothing happens.
-
-## purgeScope()
-
-```ts
-purgeScope(
-    scope: string,
-    predicate?: (id: string, value: ValidCacheData) => boolean,
-): void;
-```
-
-Purges items within a given scope (`scope`) of the cache from that scope. If a predicate is provided, only items for which the predicate returns `true` will be purged; otherwise, the entire scope will be purged.
-
-## purgeAll()
-
-```ts
-purgeAll(
-    predicate?: (
-        scope: string,
-        id: string,
-        value: ValidCacheData,
-    ) => boolean,
-): void;
-```
-
-Purges all items from the cache. If a predicate is provided, only items for which the predicate returns `true` will be purged; otherwise, the entire cache will be purged.
-

package/src/__docs__/types.valid-cache-data.stories.mdx

@@ -1,23 +0,0 @@
-import {Meta} from "@storybook/addon-docs";
-
-<Meta
-    title="Data / Types / ValidCacheData"
-    parameters={{
-        chromatic: {
-            disableSnapshot: true,
-        },
-    }}
-/>
-
-# ValidCacheData
-
-```ts
-type ValidCacheData =
-    | string
-    | boolean
-    | number
-    | {...}
-    | Array<?ValidCacheData>;
-```
-
-This type represents the data that is allowed into the various caches provided and used by Wonder Blocks Data.

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

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

package/src/util/graphql-types.js

@@ -1,30 +0,0 @@
-// @flow
-// NOTE(somewhatabstract):
-// These types are bare minimum to support document parsing. They're derived
-// from graphql@14.5.8, the last version that provided flow types.
-// Doing this avoids us having to take a dependency on that library just for
-// these types.
-export interface DefinitionNode {
-    +kind: string;
-}
-
-export type VariableDefinitionNode = {
-    +kind: "VariableDefinition",
-    ...
-};
-
-export interface OperationDefinitionNode extends DefinitionNode {
-    +kind: "OperationDefinition";
-    +operation: string;
-    +variableDefinitions: $ReadOnlyArray<VariableDefinitionNode>;
-    +name?: {|
-        +kind: mixed,
-        +value: string,
-    |};
-}
-
-export type DocumentNode = {
-    +kind: "Document",
-    +definitions: $ReadOnlyArray<DefinitionNode>,
-    ...
-};