[WIP] [Breaking] Drop Flow type support in favor of TypeScript

Author: jack-guy

__tests__/genTypeFlow.test.js renamed to __tests__/genType.test.js

@@ -1,4 +1,4 @@
-import { getResourceTypeReference, getNewKeyTypeFromBatchKeySetType, getLoaderTypeKey } from '../src/genTypeFlow';
+import { getResourceTypeReference, getNewKeyTypeFromBatchKeySetType, getLoaderTypeKey } from '../src/genType';
 
 it('getResourceTypeReference converts a resource path to a valid reference', () => {
     expect(getResourceTypeReference(null, ['foo', 'bar', 'baz'])).toBe(

__tests__/implementation.test.js

@@ -9,7 +9,7 @@ import { getConfig } from '../src/config';
 
 const BABEL_CONFIG = {
     presets: [
-        '@babel/preset-flow',
+        '@babel/preset-typescript',
         [
             '@babel/preset-env',
             {

src/codegen.ts

@@ -1,7 +1,7 @@
 import _ from 'lodash';
 import prettier from 'prettier';
 import { GlobalConfig, getResourcePaths } from './config';
-import { getLoaderType, getLoadersTypeMap, getResourceTypings } from './genTypeFlow';
+import { getLoaderType, getLoadersTypeMap, getResourceTypings } from './genType';
 import getLoaderImplementation from './implementation';
 
 function getLoaders(config: object, paths: Array<Array<string>>, current: Array<string>) {
@@ -46,8 +46,6 @@ export default function codegen(
     const { printResourceTypeImports, printResourcesType } = getResourceTypings(config);
 
     const output = `
-        // @flow strict-local
-
         /**
          * !!! THIS FILE IS AUTO-GENERATED. CHANGES MAY BE OVERWRITTEN !!!
          */
@@ -82,21 +80,22 @@ export default function codegen(
          * ===============================
          */
 
-        // https://github.com/facebook/flow/issues/7709#issuecomment-530501257
-        type ExtractArg = <Arg, Ret>([Arg => Ret]) => Arg;
-        type ExtractPromisedReturnValue<A> = <R>((...A) => Promise<R>) => R;
+        type PromisedReturnType<F extends (...args: any) => Promise<any>> =
+            F extends (...args: any) => Promise<infer R> ? R : never;
+
+        type Values<T> = T[keyof T];
 
-        export type DataLoaderCodegenOptions = {|
+        export type DataLoaderCodegenOptions = {
             errorHandler?: (
-                resourcePath: $ReadOnlyArray<string>,
-                // $FlowFixMe: We don't know what type the resource might throw, so we have to type error to "any" :(
+                resourcePath: ReadonlyArray<string>,
+                // We don't know what type the resource might throw, so we have to type error to "any" :(
                 error: any,
             ) => Promise<Error>,
-            resourceMiddleware?: {|
-                before?: <T>(resourcePath: $ReadOnlyArray<string>, resourceArgs: T) => Promise<T>,
-                after?: <T>(resourcePath: $ReadOnlyArray<string>, response: T) => Promise<T>,
-            |};
-        |};
+            resourceMiddleware?: {
+                before?: <T>(resourcePath: ReadonlyArray<string>, resourceArgs: T) => Promise<T>,
+                after?: <T>(resourcePath: ReadonlyArray<string>, response: T) => Promise<T>,
+            };
+        };
 
         /**
          * ===============================

src/genTypeFlow.ts renamed to src/genType.ts

@@ -13,39 +13,21 @@ const resourceReference = (resourcePath: ReadonlyArray<string>) => ['resources',
  * Get the reference to the type representing the resource function this resource
  */
 export function getResourceTypeReference(resourceConfig: ResourceConfig, resourcePath: ReadonlyArray<string>) {
-    function toPropertyTypePath(path: ReadonlyArray<string>): string {
-        assert(path.length >= 1, 'expected resource path to be a not empty array');
-
-        if (path.length === 1) {
-            return path[0];
-        }
-
-        return `$PropertyType<${toPropertyTypePath(path.slice(0, -1))}, '${path.slice(-1)}'>`;
-    }
-
-    return toPropertyTypePath(['ResourcesType', ...resourcePath]);
+    return `ResourcesType${resourcePath.map(segment => `['${segment}']`).join()}`;
 }
 
 function getResourceArg(resourceConfig: ResourceConfig, resourcePath: ReadonlyArray<string>) {
     // TODO: We assume that the resource accepts a single dict argument. Let's
     // make thie configurable to handle resources that use seperate arguments.
-    return `\
-        $Call<
-            ExtractArg,
-            [${getResourceTypeReference(resourceConfig, resourcePath)}]
-        >`;
+    return `Parameters<${getResourceTypeReference(resourceConfig, resourcePath)}>[0]`;
 }
 
 /**
  * Extract the type T from a Set<T> resource (in this case a batchKey's resource)
  * using its `.has(T)`'s function paremeter type
  */
 export function getNewKeyTypeFromBatchKeySetType(batchKey: string, resourceArgs: string) {
-    return `\
-        $Call<
-            ExtractArg,
-            [$PropertyType<$PropertyType<${resourceArgs}, '${batchKey}'>, 'has'>]
-        >`;
+    return `Parameters<${resourceArgs}['${batchKey}']['has']]>[0]`;
 }
 
 export function getLoaderTypeKey(resourceConfig: ResourceConfig, resourcePath: ReadonlyArray<string>) {
@@ -55,8 +37,8 @@ export function getLoaderTypeKey(resourceConfig: ResourceConfig, resourcePath: R
 
     if (resourceConfig.isBatchResource) {
         // Extract newKeyType from the batch key's Array's type
-        // We add NonMaybeType before batch key element type to force the batch key to be required, regardless if the OpenAPI spec specifies it as being optional
-        let newKeyType = `${resourceConfig.newKey}: $ElementType<$NonMaybeType<$PropertyType<${resourceArgs}, '${resourceConfig.batchKey}'>>, 0>`;
+        // We add NonNullable before batch key element type to force the batch key to be required, regardless if the OpenAPI spec specifies it as being optional
+        let newKeyType = `${resourceConfig.newKey}: NonNullable<${resourceArgs}['${resourceConfig.batchKey}']>[0]`;
 
         if (resourceConfig.isBatchKeyASet) {
             /**
@@ -69,28 +51,14 @@ export function getLoaderTypeKey(resourceConfig: ResourceConfig, resourcePath: R
             )}`;
         }
 
-        return `{|
-            ...$Diff<${resourceArgs}, {
-                ${resourceConfig.batchKey}: $PropertyType<${resourceArgs}, '${resourceConfig.batchKey}'>
-            }>,
-            ...{| ${newKeyType} |}
-        |}`;
+        return `Exclude<${resourceArgs}, '${resourceConfig.batchKey}'> & ${newKeyType}`;
     }
 
     return resourceArgs;
 }
 
 export function getLoaderTypeVal(resourceConfig: ResourceConfig, resourcePath: ReadonlyArray<string>) {
-    // TODO: We assume that the resource accepts a single dict argument. Let's
-    // make this configurable to handle resources that use seperate arguments.
-    const resourceArgs = getResourceArg(resourceConfig, resourcePath);
-
-    // TODO: DRY up in codegen to something like RetVal<resource>
-    let retVal = `\
-        $Call<
-            ExtractPromisedReturnValue<[${resourceArgs}]>,
-            ${getResourceTypeReference(resourceConfig, resourcePath)}
-        >`;
+    let retVal = `PromisedReturnType<${getResourceTypeReference(resourceConfig, resourcePath)}>`;
 
     if (resourceConfig.isBatchResource) {
         /**
@@ -115,9 +83,9 @@ export function getLoaderTypeVal(resourceConfig: ResourceConfig, resourcePath: R
          * ```
          */
         if (resourceConfig.nestedPath) {
-            retVal = `$PropertyType<${retVal}, '${resourceConfig.nestedPath}'>`;
+            retVal = `${retVal}['${resourceConfig.nestedPath}']`;
         }
-        retVal = resourceConfig.isResponseDictionary ? `$Values<${retVal}>` : `$ElementType<${retVal}, 0>`;
+        retVal = resourceConfig.isResponseDictionary ? `Values[${retVal}]` : `${retVal}[0]`;
     }
 
     return retVal;
@@ -147,17 +115,17 @@ export function getLoadersTypeMap(
     const nextValues = _.uniq(paths.map((p) => p[0]));
 
     const objectProperties: ReadonlyArray<string> = nextValues.map(
-        (nextVal) =>
+        (nextVal: any) =>
             `${nextVal}: ${getLoadersTypeMap(
                 config,
                 paths.filter((p) => p[0] === nextVal).map((p) => p.slice(1)),
                 [...current, nextVal],
             )},`,
     );
 
-    return `$ReadOnly<{|
+    return `Readonly<{
         ${objectProperties.join('\n')}
-    |}>`;
+    }>`;
 }
 
 export function getResourceTypings(

src/implementation.ts

@@ -1,6 +1,6 @@
 import { ResourceConfig, BatchResourceConfig, NonBatchResourceConfig } from './config';
 import assert from './assert';
-import { getLoaderTypeKey, getLoaderTypeVal } from './genTypeFlow';
+import { getLoaderTypeKey, getLoaderTypeVal } from './genType';
 import { errorPrefix } from './runtimeHelpers';
 
 function getLoaderComment(resourceConfig: ResourceConfig, resourcePath: ReadonlyArray<string>): string {
@@ -32,7 +32,7 @@ function callResource(resourceConfig: ResourceConfig, resourcePath: ReadonlyArra
     // Uses an iife so the result variable is assignable at the callsite (for readability)
     return `
         (async _resourceArgs => {
-            // Make a re-assignable variable so flow/eslint doesn't complain
+            // Make a re-assignable variable so eslint doesn't complain
             let __resourceArgs = _resourceArgs;
 
             if (options && options.resourceMiddleware && options.resourceMiddleware.before) {