@khanacademy/wonder-blocks-data 13.0.10 → 13.0.12

package/src/util/request-fulfillment.ts

@@ -1,121 +0,0 @@
-import type {Result, ValidCacheData} from "./types";
-
-import {DataError, DataErrors} from "./data-error";
-
-type RequestCache = {
-    [id: string]: Promise<Result<any>>;
-};
-
-type FulfillOptions<TData extends ValidCacheData> = {
-    handler: () => Promise<TData>;
-    hydrate?: boolean;
-};
-
-let _default: RequestFulfillment;
-
-/**
- * This fulfills a request, making sure that in-flight requests are shared.
- */
-export class RequestFulfillment {
-    static get Default(): RequestFulfillment {
-        if (!_default) {
-            _default = new RequestFulfillment();
-        }
-        return _default;
-    }
-
-    _requests: RequestCache = {};
-
-    /**
-     * Get a promise of a request for a given handler and options.
-     *
-     * This will return an inflight request if one exists, otherwise it will
-     * make a new request. Inflight requests are deleted once they resolve.
-     */
-    fulfill: <TData extends ValidCacheData>(
-        id: string,
-        options: FulfillOptions<TData>,
-    ) => Promise<Result<TData>> = <TData extends ValidCacheData>(
-        id: string,
-        {handler, hydrate = true}: FulfillOptions<TData>,
-    ): Promise<Result<TData>> => {
-        /**
-         * If we have an inflight request, we'll provide that.
-         */
-        const inflight = this._requests[id];
-        if (inflight) {
-            return inflight;
-        }
-
-        /**
-         * We don't have an inflight request, so let's set one up.
-         */
-        const request = handler()
-            .then(
-                (data: TData): Result<TData> => ({
-                    status: "success",
-                    data,
-                }),
-            )
-            .catch((error: string | Error): Result<TData> => {
-                const actualError =
-                    typeof error === "string"
-                        ? new DataError("Request failed", DataErrors.Unknown, {
-                              metadata: {
-                                  unexpectedError: error,
-                              },
-                          })
-                        : error;
-
-                // Return aborted result if the request was aborted.
-                // The only way to detect this reliably, it seems, is to
-                // check the error name and see if it's "AbortError" (this
-                // is also what Apollo does).
-                // Even then, it's reliant on the handler supporting aborts.
-                // TODO(somewhatabstract, FEI-4276): Add first class abort
-                // support to the handler API.
-                if (actualError.name === "AbortError") {
-                    return {
-                        status: "aborted",
-                    };
-                }
-                return {
-                    status: "error",
-                    error: actualError,
-                };
-            })
-            .finally(() => {
-                delete this._requests[id];
-            });
-
-        // Store the request in our cache.
-        this._requests[id] = request;
-
-        return request;
-    };
-
-    /**
-     * Abort an inflight request.
-     *
-     * NOTE: Currently, this does not perform an actual abort. It merely
-     * removes the request from being tracked.
-     */
-    abort: (id: string) => void = (id) => {
-        // TODO(somewhatabstract, FEI-4276): Add first class abort
-        // support to the handler API.
-        // For now, we will just clear the request out of the list.
-        // When abort is implemented, the `finally` in the `fulfill` method
-        // would handle the deletion.
-        delete this._requests[id];
-    };
-
-    /**
-     * Abort all inflight requests.
-     *
-     * NOTE: Currently, this does not perform actual aborts. It merely
-     * removes the requests from our tracking.
-     */
-    abortAll: () => void = (): void => {
-        Object.keys(this._requests).forEach((id) => this.abort(id));
-    };
-}

package/src/util/request-tracking.ts

@@ -1,211 +0,0 @@
-import * as React from "react";
-import {SsrCache} from "./ssr-cache";
-import {RequestFulfillment} from "./request-fulfillment";
-
-import type {ResponseCache, ValidCacheData} from "./types";
-
-type TrackerFn = <TData extends ValidCacheData>(
-    id: string,
-    handler: () => Promise<TData>,
-    hydrate: boolean,
-) => void;
-
-type RequestCache = {
-    [id: string]: {
-        hydrate: boolean;
-        handler: () => Promise<any>;
-    };
-};
-
-/**
- * Used to inject our tracking function into the render framework.
- *
- * INTERNAL USE ONLY
- */
-const TrackerContext: React.Context<TrackerFn | null | undefined> =
-    React.createContext<TrackerFn | null | undefined>(null);
-TrackerContext.displayName = "TrackerContext";
-export {TrackerContext};
-
-/**
- * The default instance is stored here.
- * It's created below in the Default() static property.
- */
-let _default: RequestTracker;
-
-/**
- * Implements request tracking and fulfillment.
- *
- * INTERNAL USE ONLY
- */
-export class RequestTracker {
-    static get Default(): RequestTracker {
-        if (!_default) {
-            _default = new RequestTracker();
-        }
-        return _default;
-    }
-
-    /**
-     * These are the caches for tracked requests, their handlers, and responses.
-     */
-    _trackedRequests: RequestCache = {};
-    _responseCache: SsrCache;
-    _requestFulfillment: RequestFulfillment;
-
-    constructor(responseCache?: SsrCache | null) {
-        this._responseCache = responseCache || SsrCache.Default;
-        this._requestFulfillment = new RequestFulfillment();
-    }
-
-    /**
-     * Track a request.
-     *
-     * This method caches a request and its handler for use during server-side
-     * rendering to allow us to fulfill requests before producing a final render.
-     */
-    trackDataRequest: <TData extends ValidCacheData>(
-        id: string,
-        handler: () => Promise<TData>,
-        hydrate: boolean,
-    ) => void = <TData extends ValidCacheData>(
-        id: string,
-        handler: () => Promise<TData>,
-        hydrate: boolean,
-    ): void => {
-        /**
-         * If we don't already have this tracked, then let's track it.
-         */
-        if (this._trackedRequests[id] == null) {
-            this._trackedRequests[id] = {
-                handler,
-                hydrate,
-            };
-        }
-    };
-
-    /**
-     * Reset our tracking info.
-     */
-    reset: () => void = () => {
-        this._trackedRequests = {};
-    };
-
-    /**
-     * Indicates if we have requests waiting to be fulfilled.
-     */
-    get hasUnfulfilledRequests(): boolean {
-        return Object.keys(this._trackedRequests).length > 0;
-    }
-
-    /**
-     * Initiate fulfillment of all tracked requests.
-     *
-     * This loops over the requests that were tracked using TrackData, and asks
-     * the respective handlers to fulfill those requests in the order they were
-     * tracked.
-     *
-     * Calling this method marks tracked requests as fulfilled; requests are
-     * removed from the list of tracked requests by calling this method.
-     *
-     * @returns {Promise<ResponseCache>} The promise of the data that was
-     * cached as a result of fulfilling the tracked requests.
-     */
-    fulfillTrackedRequests: () => Promise<ResponseCache> =
-        (): Promise<ResponseCache> => {
-            const promises = [];
-            const {cacheData, cacheError} = this._responseCache;
-
-            for (const requestKey of Object.keys(this._trackedRequests)) {
-                const options = this._trackedRequests[requestKey];
-
-                try {
-                    promises.push(
-                        this._requestFulfillment
-                            .fulfill(requestKey, {...options})
-                            .then((result) => {
-                                switch (result.status) {
-                                    case "success":
-                                        /**
-                                         * Let's cache the data!
-                                         *
-                                         * NOTE: This only caches when we're
-                                         * server side.
-                                         */
-                                        cacheData(
-                                            requestKey,
-                                            result.data,
-                                            options.hydrate,
-                                        );
-                                        break;
-
-                                    case "error":
-                                        /**
-                                         * Let's cache the error!
-                                         *
-                                         * NOTE: This only caches when we're
-                                         * server side.
-                                         */
-                                        cacheError(
-                                            requestKey,
-                                            result.error,
-                                            options.hydrate,
-                                        );
-                                        break;
-                                }
-
-                                // For status === "loading":
-                                // Could never get here unless we wrote
-                                // the code wrong. Rather than bloat
-                                // code with useless error, just ignore.
-
-                                // For status === "no-data":
-                                // Could never get here unless we wrote
-                                // the code wrong. Rather than bloat
-                                // code with useless error, just ignore.
-
-                                // For status === "aborted":
-                                // We won't cache this.
-                                // We don't hydrate aborted requests,
-                                // so the client would just see them
-                                // as unfulfilled data.
-                                return;
-                            }),
-                    );
-                } catch (e: any) {
-                    // This captures if there are problems in the code that
-                    // begins the requests.
-                    promises.push(
-                        Promise.resolve(
-                            cacheError(requestKey, e, options.hydrate),
-                        ),
-                    );
-                }
-            }
-
-            /**
-             * Clear out our tracked info.
-             *
-             * We call this now for a simpler API.
-             *
-             * If we reset the tracked calls after all promises resolve, any
-             * request tracking done while promises are in flight would be lost.
-             *
-             * If we don't reset at all, then we have to expose the `reset` call
-             * for consumers to use, or they'll only ever be able to accumulate
-             * more and more tracked requests, having to fulfill them all every
-             * time.
-             *
-             * Calling it here means we can have multiple "track -> request"
-             * cycles in a row and in an easy to reason about manner.
-             */
-            this.reset();
-
-            /**
-             * Let's wait for everything to fulfill, and then clone the cached data.
-             */
-            return Promise.all(promises).then(() =>
-                this._responseCache.cloneHydratableData(),
-            );
-        };
-}

package/src/util/result-from-cache-response.ts

@@ -1,30 +0,0 @@
-import {Status} from "./status";
-import {DataError, DataErrors} from "./data-error";
-import type {ValidCacheData, CachedResponse, Result} from "./types";
-
-/**
- * Turns a cache entry into a stateful result.
- */
-export const resultFromCachedResponse = <TData extends ValidCacheData>(
-    cacheEntry?: CachedResponse<TData> | null,
-): Result<TData> | null | undefined => {
-    // No cache entry means no result to be hydrated.
-    if (cacheEntry == null) {
-        return null;
-    }
-
-    const {data, error} = cacheEntry;
-    if (error != null) {
-        // Let's hydrate the error. We don't persist everything about the
-        // original error on the server, hence why we only superficially
-        // hydrate it to a GqlHydratedError.
-        return Status.error(new DataError(error, DataErrors.Hydrated));
-    }
-
-    if (data != null) {
-        return Status.success(data);
-    }
-
-    // We shouldn't get here since we don't actually cache null data.
-    return Status.aborted();
-};

package/src/util/scoped-in-memory-cache.ts

@@ -1,121 +0,0 @@
-import {DataError, DataErrors} from "./data-error";
-import type {ScopedCache, RawScopedCache, ValidCacheData} from "./types";
-
-/**
- * Describe an in-memory cache.
- */
-export class ScopedInMemoryCache implements ScopedCache {
-    _cache: RawScopedCache;
-
-    constructor(initialCache: RawScopedCache = {}) {
-        this._cache = initialCache;
-    }
-
-    /**
-     * Indicate if this cache is being used or not.
-     *
-     * When the cache has entries, returns `true`; otherwise, returns `false`.
-     */
-    get inUse(): boolean {
-        return Object.keys(this._cache).length > 0;
-    }
-
-    /**
-     * Set a value in the cache.
-     */
-    set(scope: string, id: string, value: ValidCacheData): void {
-        if (!id || typeof id !== "string") {
-            throw new DataError(
-                "id must be non-empty string",
-                DataErrors.InvalidInput,
-            );
-        }
-
-        if (!scope || typeof scope !== "string") {
-            throw new DataError(
-                "scope must be non-empty string",
-                DataErrors.InvalidInput,
-            );
-        }
-
-        if (typeof value === "function") {
-            throw new DataError(
-                "value must be a non-function value",
-                DataErrors.InvalidInput,
-            );
-        }
-
-        this._cache[scope] = this._cache[scope] ?? {};
-        this._cache[scope][id] = value;
-    }
-
-    /**
-     * Retrieve a value from the cache.
-     */
-    get(scope: string, id: string): ValidCacheData | null | undefined {
-        return this._cache[scope]?.[id] ?? null;
-    }
-
-    /**
-     * Purge an item from the cache.
-     */
-    purge(scope: string, id: string): void {
-        if (!this._cache[scope]?.[id]) {
-            return;
-        }
-        delete this._cache[scope][id];
-        if (Object.keys(this._cache[scope]).length === 0) {
-            delete this._cache[scope];
-        }
-    }
-
-    /**
-     * 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 {
-        if (!this._cache[scope]) {
-            return;
-        }
-
-        if (predicate == null) {
-            delete this._cache[scope];
-            return;
-        }
-
-        for (const key of Object.keys(this._cache[scope])) {
-            if (predicate(key, this._cache[scope][key])) {
-                delete this._cache[scope][key];
-            }
-        }
-        if (Object.keys(this._cache[scope]).length === 0) {
-            delete this._cache[scope];
-        }
-    }
-
-    /**
-     * 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 {
-        if (predicate == null) {
-            this._cache = {};
-            return;
-        }
-
-        for (const scope of Object.keys(this._cache)) {
-            this.purgeScope(scope, (id, value) => predicate(scope, id, value));
-        }
-    }
-}

package/src/util/serializable-in-memory-cache.ts

@@ -1,44 +0,0 @@
-import {clone} from "@khanacademy/wonder-stuff-core";
-import {DataError, DataErrors} from "./data-error";
-import {ScopedInMemoryCache} from "./scoped-in-memory-cache";
-import type {ValidCacheData, RawScopedCache} from "./types";
-
-/**
- * Describe a serializable in-memory cache.
- */
-export class SerializableInMemoryCache extends ScopedInMemoryCache {
-    constructor(initialCache: RawScopedCache = {}) {
-        try {
-            super(clone(initialCache));
-        } catch (e: any) {
-            throw new DataError(
-                `An error occurred trying to initialize from a response cache snapshot: ${e}`,
-                DataErrors.InvalidInput,
-            );
-        }
-    }
-
-    /**
-     * Set a value in the cache.
-     */
-    set(scope: string, id: string, value: ValidCacheData): void {
-        super.set(scope, id, Object.freeze(clone(value)));
-    }
-
-    /**
-     * Clone the cache.
-     */
-    clone(): RawScopedCache {
-        try {
-            return clone(this._cache);
-        } catch (e: any) {
-            throw new DataError(
-                "An error occurred while trying to clone the cache",
-                DataErrors.Internal,
-                {
-                    cause: e,
-                },
-            );
-        }
-    }
-}