Features/improved before one file write hook (#8662)

* allow beforeOneFileWrite to alter the content * changeset

Author: jantimon

.changeset/curvy-pens-watch.md

@@ -0,0 +1,6 @@
+---
+'@graphql-codegen/cli': minor
+'@graphql-codegen/plugin-helpers': minor
+---
+
+the life cycle hook beforeOneFileWrite is now able to modify the generated content

packages/graphql-codegen-cli/src/generate-and-save.ts

@@ -68,7 +68,7 @@ export async function generate(
  return;
  }
 
- const content = result.content || '';
+ let content = result.content || '';
  const currentHash = hash(content);
 
  if (previousHash && currentHash === previousHash) {
@@ -86,17 +86,29 @@ export async function generate(
  return;
  }
 
- await lifecycleHooks(result.hooks).beforeOneFileWrite(result.filename);
- await lifecycleHooks(config.hooks).beforeOneFileWrite(result.filename);
-
  const absolutePath = isAbsolute(result.filename)
  ? result.filename
  : join(input.cwd || process.cwd(), result.filename);
 
  const basedir = dirname(absolutePath);
  await mkdirp(basedir);
 
- await writeFile(absolutePath, content);
+ content = await lifecycleHooks(result.hooks).beforeOneFileWrite(absolutePath, content);
+ content = await lifecycleHooks(config.hooks).beforeOneFileWrite(absolutePath, content);
+
+ if (content !== result.content) {
+ result.content = content;
+ // compare the prettified content with the previous hash
+ // to compare the content with an existing prettified file
+ if (hash(content) === previousHash) {
+ debugLog(`Skipping file (${result.filename}) writing due to indentical hash after prettier...`);
+ // the modified content is NOT stored in recentOutputHash
+ // so a diff can already be detected before executing the hook
+ return;
+ }
+ }
+
+ await writeFile(absolutePath, result.content);
  recentOutputHash.set(result.filename, currentHash);
 
  await lifecycleHooks(result.hooks).afterOneFileWrite(result.filename);

packages/graphql-codegen-cli/src/hooks.ts

@@ -41,10 +41,12 @@ function execShellCommand(cmd: string): Promise<string> {
 
 async function executeHooks(
  hookName: string,
- _scripts: Types.LifeCycleHookValue = [],
- args: string[] = []
-): Promise<void> {
+ _scripts: Types.LifeCycleHookValue | Types.LifeCycleAlterHookValue = [],
+ args: string[] = [],
+ initialState?: string
+): Promise<void | string> {
  debugLog(`Running lifecycle hook "${hookName}" scripts...`);
+ let state = initialState;
  const scripts = Array.isArray(_scripts) ? _scripts : [_scripts];
 
  const quotedArgs = quote(args);
@@ -54,9 +56,16 @@ async function executeHooks(
  await execShellCommand(`${script} ${quotedArgs}`);
  } else {
  debugLog(`Running lifecycle hook "${hookName}" script: ${script.name} with args: ${args.join(' ')}...`);
- await script(...args);
+ const hookArgs = state === undefined ? args : [...args, state];
+ const hookResult = await script(...hookArgs);
+ if (typeof hookResult === 'string' && typeof state === 'string') {
+ debugLog(`Received new content from lifecycle hook "${hookName}" script: ${script.name}`);
+ state = hookResult;
+ }
  }
  }
+
+ return state;
 }
 
 export const lifecycleHooks = (_hooks: Partial<Types.LifecycleHooksDefinition> = {}) => {
@@ -66,18 +75,30 @@ export const lifecycleHooks = (_hooks: Partial<Types.LifecycleHooksDefinition> =
  };
 
  return {
- afterStart: async (): Promise<void> => executeHooks('afterStart', hooks.afterStart),
- onWatchTriggered: async (event: string, path: string): Promise<void> =>
- executeHooks('onWatchTriggered', hooks.onWatchTriggered, [event, path]),
- onError: async (error: string): Promise<void> => executeHooks('onError', hooks.onError, [error]),
- afterOneFileWrite: async (path: string): Promise<void> =>
- executeHooks('afterOneFileWrite', hooks.afterOneFileWrite, [path]),
- afterAllFileWrite: async (paths: string[]): Promise<void> =>
- executeHooks('afterAllFileWrite', hooks.afterAllFileWrite, paths),
- beforeOneFileWrite: async (path: string): Promise<void> =>
- executeHooks('beforeOneFileWrite', hooks.beforeOneFileWrite, [path]),
- beforeAllFileWrite: async (paths: string[]): Promise<void> =>
- executeHooks('beforeAllFileWrite', hooks.beforeAllFileWrite, paths),
- beforeDone: async (): Promise<void> => executeHooks('beforeDone', hooks.beforeDone),
+ afterStart: async (): Promise<void> => {
+ await executeHooks('afterStart', hooks.afterStart);
+ },
+ onWatchTriggered: async (event: string, path: string): Promise<void> => {
+ await executeHooks('onWatchTriggered', hooks.onWatchTriggered, [event, path]);
+ },
+ onError: async (error: string): Promise<void> => {
+ await executeHooks('onError', hooks.onError, [error]);
+ },
+ afterOneFileWrite: async (path: string): Promise<void> => {
+ await executeHooks('afterOneFileWrite', hooks.afterOneFileWrite, [path]);
+ },
+ afterAllFileWrite: async (paths: string[]): Promise<void> => {
+ await executeHooks('afterAllFileWrite', hooks.afterAllFileWrite, paths);
+ },
+ beforeOneFileWrite: async (path: string, content: string): Promise<string> => {
+ const result = await executeHooks('beforeOneFileWrite', hooks.beforeOneFileWrite, [path], content);
+ return typeof result === 'string' ? result : content;
+ },
+ beforeAllFileWrite: async (paths: string[]): Promise<void> => {
+ await executeHooks('beforeAllFileWrite', hooks.beforeAllFileWrite, paths);
+ },
+ beforeDone: async (): Promise<void> => {
+ await executeHooks('beforeDone', hooks.beforeDone);
+ },
  };
 };

packages/graphql-codegen-cli/tests/generate-and-save.spec.ts

@@ -213,4 +213,28 @@ describe('generate-and-save', () => {
  // makes sure it doesn't write a new file
  expect(writeSpy).toHaveBeenCalled();
  });
+ test('should allow to alter the content with the beforeOneFileWrite hook', async () => {
+ const filename = 'modify.ts';
+ const writeSpy = jest.spyOn(fs, 'writeFile').mockImplementation();
+
+ const output = await generate(
+ {
+ schema: SIMPLE_TEST_SCHEMA,
+ generates: {
+ [filename]: {
+ plugins: ['typescript'],
+ hooks: {
+ beforeOneFileWrite: [() => 'new content'],
+ },
+ },
+ },
+ },
+ true
+ );
+
+ expect(output.length).toBe(1);
+ expect(output[0].content).toMatch('new content');
+ // makes sure it doesn't write a new file
+ expect(writeSpy).toHaveBeenCalled();
+ });
 });

packages/utils/plugins-helpers/src/types.ts

@@ -523,8 +523,14 @@ export namespace Types {
  export type ComplexPluginOutput = { content: string; prepend?: string[]; append?: string[] };
  export type PluginOutput = string | ComplexPluginOutput;
  export type HookFunction = (...args: any[]) => void | Promise<void>;
+ export type HookAlterFunction = (...args: any[]) => void | string | Promise<void | string>;
 
  export type LifeCycleHookValue = string | HookFunction | (string | HookFunction)[];
+ export type LifeCycleAlterHookValue =
+ | string
+ | HookFunction
+ | HookAlterFunction
+ | (string | HookFunction | HookAlterFunction)[];
 
  /**
  * @description All available lifecycle hooks
@@ -565,11 +571,14 @@ export namespace Types {
  */
  afterAllFileWrite: LifeCycleHookValue;
  /**
- * @description Triggered before a file is written to the file-system. Executed with the path for the file.
+ * @description Triggered before a file is written to the file-system.
+ * Executed with the path and content for the file.
+ *
+ * Returning a string will override the content of the file.
  *
  * If the content of the file hasn't changed since last execution - this hooks won't be triggered.
  */
- beforeOneFileWrite: LifeCycleHookValue;
+ beforeOneFileWrite: LifeCycleAlterHookValue;
  /**
  * @description Executed after the codegen has done creating the output and before writing the files to the file-system.
  *