Auto-generate TypeScript types for metro-cache (#1576)

Summary:
Pull Request resolved: #1576

Auto-generate TypeScript defs for the `metro-cache` package using `flow-api-translator`, and enforce that they remain in sync.

## Why `metro-cache`?
 - It's relatively small, so easy to review these changes by eye while this is a new process.
 - Its types have no dependencies on any other package (Metro, Node or otherwise)
 - It's a dependency of `metro-config`, which is the most important to start auto-generating in terms of user impact - all RN users interact with `metro-config`'s types.

Changelog: Internal

Reviewed By: vzaidman

Differential Revision: D81125128

fbshipit-source-id: d33cef3bb91dc74ecac0ad7cf83d260a0fae9c32

Author: robhogan

packages/metro-cache/types/Cache.d.ts

@@ -8,18 +8,18 @@
  * @oncall react_native
  */
 
-import {CacheStore} from './types';
-
+import type {CacheStore} from './types';
 /**
  * Main cache class. Receives an array of cache instances, and sequentially
  * traverses them to return a previously stored value. It also ensures setting
  * the value in all instances.
  *
  * All get/set operations are logged via Metro's logger.
  */
-export default class Cache<T> {
+declare class Cache<T> {
   constructor(stores: ReadonlyArray<CacheStore<T>>);
-  get(key: Buffer): Promise<T | null>;
+  get(key: Buffer): Promise<null | undefined | T>;
   set(key: Buffer, value: T): Promise<void>;
   get isDisabled(): boolean;
 }
+export default Cache;

packages/metro-cache/types/index.d.ts

@@ -26,21 +26,21 @@ export {
   HttpStore,
   stableHash,
 };
-
 export interface MetroCache {
-  AutoCleanFileStore: typeof AutoCleanFileStore;
-  Cache: typeof Cache;
-  FileStore: typeof FileStore;
-  HttpGetStore: typeof HttpGetStore;
-  HttpStore: typeof HttpStore;
-  stableHash: typeof stableHash;
+  readonly AutoCleanFileStore: typeof AutoCleanFileStore;
+  readonly Cache: typeof Cache;
+  readonly FileStore: typeof FileStore;
+  readonly HttpGetStore: typeof HttpGetStore;
+  readonly HttpStore: typeof HttpStore;
+  readonly stableHash: typeof stableHash;
 }
-
 /**
  * Backwards-compatibility with CommonJS consumers using interopRequireDefault.
  * Do not add to this list.
  *
  * @deprecated Default import from 'metro-cache' is deprecated, use named exports.
  */
 declare const $$EXPORT_DEFAULT_DECLARATION$$: MetroCache;
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
 export default $$EXPORT_DEFAULT_DECLARATION$$;

packages/metro-cache/types/stableHash.d.ts

@@ -8,4 +8,5 @@
  * @oncall react_native
  */
 
-export default function stableHash(value: unknown): Buffer;
+declare function stableHash(value: unknown): Buffer;
+export default stableHash;

packages/metro-cache/types/stores/AutoCleanFileStore.d.ts

@@ -8,8 +8,16 @@
  * @oncall react_native
  */
 
-import type FileStore from './FileStore';
+import type {Options} from './FileStore';
 
+import FileStore from './FileStore';
+
+type CleanOptions = Readonly<
+  Omit<Options, keyof {intervalMs?: number; cleanupThresholdMs?: number}> & {
+    intervalMs?: number;
+    cleanupThresholdMs?: number;
+  }
+>;
 /**
  * A FileStore that, at a given interval, stats the content of the cache root
  * and deletes any file last modified a set threshold in the past.
@@ -18,4 +26,7 @@ import type FileStore from './FileStore';
  * redundant I/O when caches are large. Prefer your own cleanup scripts, or a
  * custom Metro cache that uses watches, hooks get/set, and/or implements LRU.
  */
-export default class AutoCleanFileStore<T> extends FileStore<T> {}
+declare class AutoCleanFileStore<T> extends FileStore<T> {
+  constructor(opts: CleanOptions);
+}
+export default AutoCleanFileStore;

packages/metro-cache/types/stores/FileStore.d.ts

@@ -8,13 +8,11 @@
  * @oncall react_native
  */
 
-export interface Options {
-  root: string;
-}
-
-export default class FileStore<T> {
+export type Options = Readonly<{root: string}>;
+declare class FileStore<T> {
   constructor(options: Options);
-  get(key: Buffer): Promise<T | null>;
+  get(key: Buffer): Promise<null | undefined | T>;
   set(key: Buffer, value: T): Promise<void>;
   clear(): void;
 }
+export default FileStore;

packages/metro-cache/types/stores/HttpError.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+declare class HttpError extends Error {
+  code: number;
+  constructor(message: string, code: number);
+}
+export default HttpError;

packages/metro-cache/types/stores/HttpGetStore.d.ts

@@ -8,11 +8,13 @@
  * @oncall react_native
  */
 
-import type {Options} from './HttpStore';
+import type {Options as HttpOptions} from './HttpStore';
 
-export default class HttpGetStore<T> {
-  constructor(options: Options);
-  get(key: Buffer): Promise<T | null>;
-  set(key: Buffer, value: T): Promise<void>;
-  clear(): void;
+import HttpStore from './HttpStore';
+
+declare class HttpGetStore<T> extends HttpStore<T> {
+  constructor(options: HttpOptions);
+  get(key: Buffer): Promise<null | undefined | T>;
+  set(_key: Buffer, _value: T): Promise<void>;
 }
+export default HttpGetStore;

packages/metro-cache/types/stores/HttpStore.d.ts

@@ -8,18 +8,41 @@
  * @oncall react_native
  */
 
-export interface Options {
+import HttpError from './HttpError';
+import NetworkError from './NetworkError';
+
+export type Options =
+  | EndpointOptions
+  | {getOptions: EndpointOptions; setOptions: EndpointOptions};
+type EndpointOptions = {
   endpoint: string;
   family?: 4 | 6;
   timeout?: number;
   key?: string | ReadonlyArray<string> | Buffer | ReadonlyArray<Buffer>;
   cert?: string | ReadonlyArray<string> | Buffer | ReadonlyArray<Buffer>;
   ca?: string | ReadonlyArray<string> | Buffer | ReadonlyArray<Buffer>;
-}
-
-export default class HttpStore<T> {
+  params?: URLSearchParams;
+  headers?: {[$$Key$$: string]: string};
+  additionalSuccessStatuses?: ReadonlyArray<number>;
+  /**
+   * Whether to include additional debug information in error messages.
+   */
+  debug?: boolean;
+  /**
+   * Retry configuration
+   */
+  maxAttempts?: number;
+  retryNetworkErrors?: boolean;
+  retryStatuses?: ReadonlySet<number>;
+  socketPath?: string;
+  proxy?: string;
+};
+declare class HttpStore<T> {
+  static HttpError: typeof HttpError;
+  static NetworkError: typeof NetworkError;
   constructor(options: Options);
-  get(key: Buffer): Promise<T | null>;
+  get(key: Buffer): Promise<null | undefined | T>;
   set(key: Buffer, value: T): Promise<void>;
   clear(): void;
 }
+export default HttpStore;

packages/metro-cache/types/stores/NetworkError.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+declare class NetworkError extends Error {
+  code: string;
+  constructor(message: string, code: string);
+}
+export default NetworkError;

packages/metro-cache/types/types.d.ts

@@ -9,7 +9,8 @@
  */
 
 export interface CacheStore<T> {
-  get(key: Buffer): T | undefined | Promise<T> | Promise<undefined>;
+  name?: string;
+  get(key: Buffer): (null | undefined | T) | Promise<null | undefined | T>;
   set(key: Buffer, value: T): void | Promise<void>;
   clear(): void | Promise<void>;
 }