refactor: autoFixService

Author: cometkim

.pnp.js

@@ -63,10 +63,12 @@
     "@babel/preset-typescript": "^7.12.7",
     "@babel/runtime": "^7.12.5",
     "@cometjs/eslint-plugin": "^0.2.1",
+    "@cometjs/jest-utils": "^0.1.0",
     "@types/async": "^3.2.5",
     "@types/common-tags": "^1.8.0",
     "@types/graphql": "^14.5.0",
     "@types/jest": "^26.0.19",
+    "@types/jest-when": "^2.7.2",
     "@types/node": "^14.14.19",
     "@typescript-eslint/eslint-plugin": "^4.11.1",
     "@typescript-eslint/parser": "^4.11.1",
@@ -76,6 +78,7 @@
     "gatsby": "^2.30.1",
     "graphql": "^14.7.0",
     "jest": "^26.6.3",
+    "jest-when": "^3.1.0",
     "redux": "^4.0.5",
     "typescript": "^4.1.3",
     "utility-types": "^3.10.0"

.yarn/cache/@cometjs-jest-utils-npm-0.1.0-0c4a0ecb92-87383c9ebe.zip

@@ -0,0 +1,32 @@
+import { Machine, actions } from 'xstate';
+
+import type {
+  AutoFixContext,
+  AutoFixEvent,
+  AutoFixConfig,
+} from './types';
+
+const machine = Machine<AutoFixContext, AutoFixEvent>({
+  initial: 'pending',
+  states: {
+    pending: {
+      invoke: {
+        src: 'autoFixCode',
+        onDone: 'settled',
+      },
+    },
+    settled: {
+      type: 'final',
+      entry: 'reportRejectedResults',
+    },
+  },
+});
+
+interface MakeAutoFixCodeScheduler {
+  (args: {
+    config: AutoFixConfig,
+  }): typeof machine;
+}
+export const makeAutoFixCodeScheduler: MakeAutoFixCodeScheduler = ({ config }) => {
+  return machine.withConfig(config);
+};

.yarn/cache/@jest-console-npm-24.9.0-5313ae2fdc-74f7e051e6.zip

@@ -0,0 +1,75 @@
+import { when } from 'jest-when';
+import { stripIndent } from 'common-tags';
+import { deeplyMock } from '@cometjs/jest-utils';
+
+import { autoFixFiles } from './service';
+
+const [commonMock] = deeplyMock<typeof import('../../common')>('common');
+
+describe('autoFixFiles', () => {
+  it('should insert type definitions automatically for TypeScript files', async () => {
+    when(commonMock.readFile)
+      .calledWith('use-static-query.ts').mockResolvedValueOnce(stripIndent`
+        const data = useStaticQuery(graphql\`
+          query Test {
+            test
+          }
+        \`)
+      `)
+      .calledWith('static-query-component.tsx').mockResolvedValueOnce(stripIndent`
+        return (
+          <StaticQuery
+            query={graphql\`
+              query Test {
+                test
+              }
+            \`}
+            render={data => (
+              <TestComponent test={data.test} />
+            )}
+          />
+        );
+      `);
+
+    await expect(autoFixFiles({
+      files: ['use-static-query.ts', 'static-query-component.tsx'],
+      // @ts-ignore
+      pluginOptions: {
+        language: 'typescript',
+        namespace: 'GatsbyTypes',
+      },
+    })).resolves.toEqual([
+      {
+        status: 'fullfilled',
+        value: undefined,
+      },
+      {
+        status: 'fullfilled',
+        value: undefined,
+      },
+    ]);
+
+    expect(commonMock.writeFile).toBeCalledWith('use-static-query.ts', stripIndent`
+      const data = useStaticQuery<TestQuery>(graphql\`
+        query Test {
+          test
+        }
+      \`);
+    `);
+
+    expect(commonMock.writeFile).toBeCalledWith('static-query-component.tsx', stripIndent`
+      return (
+        <StaticQuery<TestQuery>
+          query={graphql\`
+            query Test {
+              test
+            }
+          \`}
+          render={data => (
+            <TestComponent test={data.test} />
+          )}
+        />
+      );
+    `);
+  });
+});

.yarn/cache/@jest-source-map-npm-24.9.0-002ea1ff91-1bbebf706b.zip

@@ -0,0 +1,170 @@
+import path from 'path';
+import { mapOption } from '@cometjs/core';
+import { readFile, writeFile } from '../../common';
+
+import type { AutoFixContext } from './types';
+
+/**
+ * (?<CallExpressionName>useStaticQuery
+ *   (?<TypeTemplate><
+ *     (?<TypeArgument>\S*)
+ *   >)?
+ * )
+ * \([\s\S]*?
+ * graphql
+ * (?<TemplateLiteral>`\s*?
+ *   (?<QueryDefinitionStart>query
+ *     (?<QueryName>\S*)
+ *     [^{]?\{
+ *   )
+ *   [^`]*?
+ * `)
+ */
+const STATIC_QUERY_HOOK_REGEXP = /(?<CallExpressionName>useStaticQuery(?<TypeTemplate><(?<TypeArgument>\S*)>)?)\([\s\S]*?graphql(?<TemplateLiteral>`\s*?(?<QueryDefinitionStart>query (?<QueryName>\S*)[^{]{)[^`]*?`)/g;
+
+/**
+ * (?<JsxTagOpening><StaticQuery
+ *   (?<TagTypeTemplate><
+ *     (?<TagTypeArgument>\S+)
+ *   >)?
+ * )
+ * [\s\S]+?
+ * query={
+ * [\s\S]*?
+ * graphql
+ * (?<TemplateLiteral>`\s*?
+ *   (?<QueryDefinitionStart>query
+ *     (?<QueryName>\S*)
+ *     [^{]?\{
+ *   )
+ *   [^`]*?
+ * `)
+ */
+const STATIC_QUERY_COMPONENT_REGEXP = /(?<JsxTagOpening><StaticQuery(?<TagTypeTemplate><(?<TagTypeArgument>\S+)>)?)[\s\S]+?query={[\s\S]*?graphql(?<TemplateLiteral>`\s*?(?<QueryDefinitionStart>query (?<QueryName>\S*)[^{]?\{)[^`]*`)/g;
+
+interface FixCodeFn {
+  (args: {
+    code: string,
+    namespace: string,
+  }): string;
+}
+const fixTypeScript: FixCodeFn = ({ code, namespace }) => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return code
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    .replace(STATIC_QUERY_HOOK_REGEXP, (substring: string, ...args: any[]) => {
+      const { length: l, [l - 1]: groups } = args;
+      return substring.replace(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        groups['CallExpressionName'],
+        // eslint-disable-next-line
+        `useStaticQuery<${namespace}.${groups['QueryName']}Query>`,
+      );
+    })
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    .replace(STATIC_QUERY_COMPONENT_REGEXP, (substring: string, ...args: any[]) => {
+      const { length: l, [l - 1]: groups } = args;
+      return substring.replace(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        groups['JsxTagOpening'],
+        // eslint-disable-next-line
+        `<StaticQuery<${namespace}.${groups['QueryName']}Query>`,
+      );
+    });
+};
+const fixFlow: FixCodeFn = ({ code, namespace }) => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return code
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    .replace(STATIC_QUERY_HOOK_REGEXP, (substring: string, ...args: any[]) => {
+      const { length: l, [l - 1]: groups } = args;
+      return substring.replace(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        groups['CallExpressionName'],
+        // eslint-disable-next-line
+        `useStaticQuery<${namespace}$${groups['QueryName']}Query>`,
+      );
+    })
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    .replace(STATIC_QUERY_COMPONENT_REGEXP, (substring: string, ...args: any[]) => {
+      const { length: l, [l - 1]: groups } = args;
+      return substring.replace(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        groups['JsxTagOpening'],
+        // eslint-disable-next-line
+        `<StaticQuery<${namespace}$${groups['QueryName']}Query>`,
+      );
+    });
+};
+
+const lookupFirstComment = (code: string) => {
+  const result = /(\/\/(.*)|\/\*([\s\S]*)\*\/)/.exec(code);
+  return mapOption(result, ([match]) => match);
+};
+
+const hasFlowComment = (code: string) => {
+  const firstComment = lookupFirstComment(code);
+  return mapOption(firstComment, {
+    some: () => true,
+    none: () => false,
+  });
+};
+
+const isJavaScriptFile = (file: string): boolean => {
+  const ext = path.extname(file);
+  return /jsx?/.test(ext);
+};
+
+const isTypeScriptFile = (file: string): boolean => {
+  const ext = path.extname(file);
+  return /tsx?/.test(ext);
+};
+
+interface AutoFixFileFn {
+  (args: {
+    file: string,
+    namespace: string,
+  }): Promise<void>;
+}
+
+const autoFixTypeScriptFile: AutoFixFileFn = async ({ file, namespace }) => {
+  const code = await readFile(file);
+  const fixed = fixTypeScript({ code, namespace });
+  if (code !== fixed) {
+    await writeFile(file, fixed);
+  }
+};
+
+const autoFixFlowFile: AutoFixFileFn = async ({ file, namespace }) => {
+  const code = await readFile(file);
+  if (!hasFlowComment(code)) {
+    return;
+  }
+
+  const fixed = fixFlow({ code, namespace });
+  if (code !== fixed) {
+    await writeFile(file, fixed);
+  }
+};
+
+export const autoFixFiles = ({
+  files,
+  pluginOptions: {
+    language,
+    namespace,
+  },
+}: AutoFixContext): Promise<Array<PromiseSettledResult<void>>> => {
+  if (language === 'typescript') {
+    return Promise.allSettled(
+      files
+      .filter(isTypeScriptFile)
+      .map(file => autoFixTypeScriptFile({ file, namespace })),
+    );
+  } else {
+    return Promise.allSettled(
+      files
+      .filter(isJavaScriptFile)
+      .map(file => autoFixFlowFile({ file, namespace })),
+    );
+  }
+};

.yarn/cache/@jest-test-result-npm-24.9.0-036a1293e5-e8e91f3dbd.zip

@@ -0,0 +1,44 @@
+import type {
+  ActionObject,
+  ActionFunction,
+  ServiceConfig,
+  AnyEventObject,
+} from 'xstate';
+import type { Unwrap } from '@cometjs/core';
+import type { RequiredPluginOptions } from '../../../plugin-utils';
+import type { autoFixFiles } from './service';
+
+export type AutoFixContext = {
+  files: string[],
+  pluginOptions: RequiredPluginOptions,
+};
+
+export type AutoFixEvent = (
+  | { type: 'done.invoke.autoFixFiles', data: Unwrap<ReturnType<typeof autoFixFiles>> }
+);
+
+export type AutoFixActionName = (
+  | 'reportAutoFixResults'
+);
+
+export type AutoFixActionMap = Record<
+  AutoFixActionName,
+  (
+    | ActionObject<AutoFixContext, AutoFixEvent>
+    | ActionFunction<AutoFixContext, AutoFixEvent>
+  )
+>;
+
+export type AutoFixServiceName = (
+  | 'autoFixFiles'
+);
+
+export type AutoFixServiceMap = Record<
+  AutoFixServiceName,
+  ServiceConfig<AutoFixContext, AutoFixEvent>
+>;
+
+export type AutoFixConfig = {
+  actions: AutoFixActionMap,
+  services: AutoFixServiceMap,
+};

.yarn/cache/@jest-types-npm-24.9.0-d3aae63b88-7cd388ad9d.zip

@@ -0,0 +1,3 @@
+{
+  "extends": "../tsconfig.json"
+}