chore(repo): change to file based nx-payload plugin

closed COD-346

Author: hakalb

nx.json

@@ -268,6 +268,6 @@
         "serveStaticTargetName": "serve-static"
       }
     },
-    "@cdwr/nx-payload/plugin"
+    "./packages/nx-payload/plugin.ts"
   ]
 }

package.json

@@ -85,7 +85,6 @@
   "devDependencies": {
     "@babel/core": "^7.14.5",
     "@babel/preset-react": "^7.14.5",
-    "@cdwr/nx-payload": "2.0.0",
     "@clack/prompts": "^0.11.0",
     "@commitlint/cli": "^19.0.0",
     "@commitlint/config-angular": "^19.0.0",

packages/nx-payload/src/plugins/utils/create-payload-nodes.ts

@@ -1,4 +1,3 @@
-import { readFile } from 'fs/promises';
 import { dirname, join, relative } from 'path/posix';
 
 import {
@@ -15,6 +14,7 @@ import { getLockFileName } from '@nx/js';
 
 import { createPayloadTargets } from '../../utils/create-payload-targets';
 import { findUpFs } from '../../utils/find-up-fs';
+import { isGraphQLDisabled } from '../../utils/is-graphql-disabled';
 
 import {
   type PayloadPluginOptions,
@@ -41,8 +41,9 @@ export const createPayloadNodes = async (
   // Convert to POSIX on Windows (workspacePath is os formatted)
   const workspaceRoot = normalizePath(context.workspaceRoot);
 
-  // configFilePath is POSIX formatted
+  // configFilePath is POSIX formatted, convert to absolute OS-specific paths for file reading
   const configRoot = dirname(configFilePath);
+  const fullConfigPath = join(workspaceRoot, configFilePath);
   const fullConfigRoot = join(workspaceRoot, configRoot);
 
   // Payload config file can be located anywhere, though it's generated initially in the 'src' folder.
@@ -65,24 +66,21 @@ export const createPayloadNodes = async (
     readJsonFile<ProjectConfiguration>(projectJsonPath);
 
   // Get current GraphQL config state
-  const configContent = await readFile(configFilePath, 'utf-8');
-  const isGraphQLDisabled = /graphQL:\s*\{[^}]*disable:\s*true[^}]*\}/.test(
-    configContent
-  );
+  const graphQLDisabled = await isGraphQLDisabled(fullConfigPath);
 
   const hash = await calculateHashForCreateNodes(
     projectRoot,
     normalizePluginOptions(options),
     context,
     [
       getLockFileName(detectPackageManager(workspaceRoot)),
-      String(isGraphQLDisabled)
+      String(graphQLDisabled)
     ]
   );
 
   // Get payload targets to be inferred for the project
   targetsCache[hash] ??= createPayloadTargets({
-    isGraphQLDisabled,
+    isGraphQLDisabled: graphQLDisabled,
     projectName: String(projectName), // Should have a value by design?
     projectRoot
   });

packages/nx-payload/src/utils/is-graphql-disabled.spec.ts

@@ -0,0 +1,208 @@
+import { readFile } from 'fs/promises';
+
+import { isGraphQLDisabled } from './is-graphql-disabled';
+
+jest.mock('fs/promises');
+
+describe('isGraphQLDisabled', () => {
+  const mockReadFile = jest.mocked(readFile);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should return true when graphQL.disable is true (basic format)', async () => {
+    const content = `
+      export default buildConfig({
+        graphQL: { disable: true }
+      })
+    `;
+    mockReadFile.mockResolvedValue(content);
+
+    const result = await isGraphQLDisabled('/path/to/config.ts');
+
+    expect(result).toBe(true);
+    expect(mockReadFile).toHaveBeenCalledWith('/path/to/config.ts', 'utf-8');
+  });
+
+  it('should return true when graphQL.disable is true (with trailing comma)', async () => {
+    const content = `
+      export default buildConfig({
+        graphQL: { disable: true, }
+      })
+    `;
+    mockReadFile.mockResolvedValue(content);
+
+    expect(await isGraphQLDisabled('/path/to/config.ts')).toBe(true);
+  });
+
+  it('should return true when disable is first property', async () => {
+    const content = `
+      export default buildConfig({
+        graphQL: {
+          disable: true,
+          schema: { /* ... */ }
+        }
+      })
+    `;
+    mockReadFile.mockResolvedValue(content);
+
+    expect(await isGraphQLDisabled('/path/to/config.ts')).toBe(true);
+  });
+
+  it('should return true when disable is middle property', async () => {
+    const content = `
+      export default buildConfig({
+        graphQL: {
+          schema: { /* ... */ },
+          disable: true,
+          playground: false
+        }
+      })
+    `;
+    mockReadFile.mockResolvedValue(content);
+
+    expect(await isGraphQLDisabled('/path/to/config.ts')).toBe(true);
+  });
+
+  it('should return true when disable is last property', async () => {
+    const content = `
+      export default buildConfig({
+        graphQL: {
+          schema: { /* ... */ },
+          disable: true
+        }
+      })
+    `;
+    mockReadFile.mockResolvedValue(content);
+
+    expect(await isGraphQLDisabled('/path/to/config.ts')).toBe(true);
+  });
+
+  it('should return true with no spaces around colons', async () => {
+    const content = `
+      export default buildConfig({
+        graphQL:{disable:true}
+      })
+    `;
+    mockReadFile.mockResolvedValue(content);
+
+    expect(await isGraphQLDisabled('/path/to/config.ts')).toBe(true);
+  });
+
+  it('should return true with multiple newlines and spaces', async () => {
+    const content = `
+      export default buildConfig({
+        graphQL: {
+
+          disable:     true
+
+        }
+      })
+    `;
+    mockReadFile.mockResolvedValue(content);
+
+    expect(await isGraphQLDisabled('/path/to/config.ts')).toBe(true);
+  });
+
+  it('should return false when graphQL.disable is false', async () => {
+    const content = `
+      export default buildConfig({
+        graphQL: { disable: false }
+      })
+    `;
+    mockReadFile.mockResolvedValue(content);
+
+    expect(await isGraphQLDisabled('/path/to/config.ts')).toBe(false);
+  });
+
+  it('should return false when graphQL.disable is missing', async () => {
+    const content = `
+      export default buildConfig({
+        graphQL: { schema: { /* ... */ } }
+      })
+    `;
+    mockReadFile.mockResolvedValue(content);
+
+    expect(await isGraphQLDisabled('/path/to/config.ts')).toBe(false);
+  });
+
+  it('should return false when graphQL config is missing', async () => {
+    const content = `
+      export default buildConfig({
+        collections: []
+      })
+    `;
+    mockReadFile.mockResolvedValue(content);
+
+    expect(await isGraphQLDisabled('/path/to/config.ts')).toBe(false);
+  });
+
+  it('should not match commented out disable', async () => {
+    const content = `
+      export default buildConfig({
+        graphQL: {
+          // disable: true
+          schema: { /* ... */ }
+        }
+      })
+    `;
+    mockReadFile.mockResolvedValue(content);
+
+    expect(await isGraphQLDisabled('/path/to/config.ts')).toBe(false);
+  });
+
+  it('should return false when file read fails', async () => {
+    const consoleWarnSpy = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => {
+        // Suppress console output during tests
+      });
+    mockReadFile.mockRejectedValue(new Error('File not found'));
+
+    const result = await isGraphQLDisabled('/path/to/config.ts');
+
+    expect(result).toBe(false);
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to check GraphQL status'),
+      'File not found'
+    );
+
+    consoleWarnSpy.mockRestore();
+  });
+
+  it('should return false when file read throws non-Error', async () => {
+    const consoleWarnSpy = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => {
+        // Suppress console output during tests
+      });
+    mockReadFile.mockRejectedValue('Some string error');
+
+    const result = await isGraphQLDisabled('/path/to/config.ts');
+
+    expect(result).toBe(false);
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to check GraphQL status'),
+      'Some string error'
+    );
+
+    consoleWarnSpy.mockRestore();
+  });
+
+  it('should handle empty file', async () => {
+    mockReadFile.mockResolvedValue('');
+
+    expect(await isGraphQLDisabled('/path/to/config.ts')).toBe(false);
+  });
+
+  it('should handle malformed content gracefully', async () => {
+    mockReadFile.mockResolvedValue('{');
+
+    expect(await isGraphQLDisabled('/path/to/config.ts')).toBe(false);
+  });
+});

packages/nx-payload/src/utils/is-graphql-disabled.ts

@@ -0,0 +1,33 @@
+import { readFile } from 'fs/promises';
+
+/**
+ * Checks if GraphQL is disabled in a Payload config file.
+ *
+ * @param configFilePath - Path to the Payload config file
+ * @returns Promise resolving to true if GraphQL is disabled, false otherwise
+ */
+export const isGraphQLDisabled = async (
+  configFilePath: string
+): Promise<boolean> => {
+  try {
+    const configContent = await readFile(configFilePath, 'utf-8');
+
+    // Remove single-line comments to avoid false positives
+    const contentWithoutComments = configContent.replace(/\/\/.*$/gm, '');
+
+    // Match graphQL config with disable: true
+    // Pattern allows disable property to appear anywhere in the graphQL object
+    // Handles various formatting: spaces, newlines, with/without trailing commas
+    // [\s\S]* matches any character including newlines
+    const pattern = /graphQL:\s*\{[\s\S]*?disable:\s*true[\s\S]*?\}/;
+    return pattern.test(contentWithoutComments);
+  } catch (error) {
+    // If we can't read the file or parse it, assume GraphQL is not disabled
+    // This prevents the plugin from breaking due to file system errors
+    console.warn(
+      `Failed to check GraphQL status in ${configFilePath}:`,
+      error instanceof Error ? error.message : String(error)
+    );
+    return false;
+  }
+};