feat(nx-plugin): add support for different clients and plugins

Author: seriouslag

Diff for: packages/nx-plugin/README.md

@@ -16,7 +16,7 @@ Run `nx g @hey-api/nx-plugin:openapi-client`
 - `scope`: The scope of the project. (required)
 - `spec`: The path to the OpenAPI spec file. (required)
 - `directory`: The directory to create the project in. (optional) (default: `libs`)
-- `client`: The type of client to generate. (optional) (default: `fetch`)
+- `client`: The type of client to generate. (optional) (default: `@hey-api/client-fetch`)
 - `tags`: The tags to add to the project. (optional) (default: `api,openapi`)
 
 #### Example
@@ -37,7 +37,8 @@ Run `nx run @my-org/my-generated-package:updateApi`
 #### Options
 
 - `spec`: The path to the OpenAPI spec file. (required)
-- `client`: The type of client to generate. (optional) (default: `fetch`)
-- `directory`: The directory to create the project in. (optional) (default: `libs`)
 - `name`: The name of the project. (required)
 - `scope`: The scope of the project. (required)
+- `client`: The type of client to generate. (optional) (default: `@hey-api/client-fetch`)
+- `directory`: The directory to create the project in. (optional) (default: `libs`)
+- `plugins`: Additional plugins to provide to the client api. (optional) (default:[])

Diff for: packages/nx-plugin/package.json

@@ -25,7 +25,7 @@
     "swagger"
   ],
   "private": true,
-  "type": "module",
+  "type": "commonjs",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",

Diff for: packages/nx-plugin/src/executors/update-api/index.spec.ts

@@ -1,17 +1,22 @@
 import type { ExecutorContext } from '@nx/devkit';
-import { describe, expect, it } from 'vitest';
+import { existsSync } from 'fs';
+import { mkdir, rm, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import executor from '.';
 import type { UpdateApiExecutorSchema } from './schema';
 
 const options: UpdateApiExecutorSchema = {
   client: 'fetch',
-  directory: 'libs',
+  // don't use tmp, as it is used internally in the lib code for temp files
+  directory: 'temp',
   name: 'my-api',
   plugins: [],
   scope: '@my-org',
   spec: '',
 };
+
 const context: ExecutorContext = {
   cwd: process.cwd(),
   isVerbose: false,
@@ -21,13 +26,55 @@ const context: ExecutorContext = {
     nodes: {},
   },
   projectsConfigurations: {
-    projects: {},
+    projects: {
+      'my-api': {
+        root: 'libs/my-api',
+        targets: {},
+      },
+    },
     version: 2,
   },
   root: '',
 };
 
 describe('UpdateApi Executor', () => {
+  beforeEach(async () => {
+    // Create the API directory and spec file
+    const apiDir = join(process.cwd(), options.directory, options.name, 'api');
+    if (!existsSync(apiDir)) {
+      await mkdir(apiDir, { recursive: true });
+    }
+    const specPath = join(apiDir, 'spec.yaml');
+    const validSpec = `
+openapi: 3.0.0
+info:
+  title: Test API
+  version: 1.0.0
+paths:
+  /test:
+    get:
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  message:
+                    type: string
+`;
+    await writeFile(specPath, validSpec);
+    options.spec = specPath;
+  });
+
+  afterEach(async () => {
+    const apiDir = join(process.cwd(), options.directory);
+    if (existsSync(apiDir)) {
+      await rm(apiDir, { force: true, recursive: true });
+    }
+  });
+
   it('can run', async () => {
     const output = await executor(options, context);
     expect(output.success).toBe(true);

Diff for: packages/nx-plugin/src/executors/update-api/schema.json

@@ -22,9 +22,8 @@
     "client": {
       "type": "string",
       "description": "The type of client to generate",
-      "x-prompt": "What is the type of client to generate? (fetch, axios)",
-      "default": "fetch",
-      "enum": ["fetch", "axios"]
+      "x-prompt": "What is the type of client to generate? (@hey-api/client-fetch, @hey-api/client-axios)",
+      "default": "@hey-api/client-fetch"
     },
     "scope": {
       "type": "string",

Diff for: packages/nx-plugin/src/generators/openapi-client/README.md

@@ -97,6 +97,6 @@ The generator also uses `@redocly/cli` for bundling the spec file.
 - [x] Generate the client code
 - [x] Setup tests
 - [x] Add generator to update the API spec file and regenerate the client code
-- [ ] Make plugins configurable and ability to add additional plugins
+- [x] Make plugins configurable and ability to add additional plugins
+- [x] Support additional client types
 - [ ] Support different test frameworks
-- [ ] Support additional client types

Diff for: packages/nx-plugin/src/generators/openapi-client/files/package.json.template

@@ -9,13 +9,7 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
-    },
-    "./rq": {
-      "development": "./src/rq.ts",
-      "types": "./dist/rq.d.ts",
-      "import": "./dist/rq.js",
-      "default": "./dist/rq.js"
-    },
+    }
   },
   "scripts": {
     "update": "nx run <%= projectScope %>/<%= projectName %>:updateApi"

Diff for: packages/nx-plugin/src/generators/openapi-client/index.spec.ts

@@ -67,7 +67,7 @@ describe('openapi-client generator', () => {
   let tempSpecPath: string;
 
   const options = {
-    client: 'fetch' as const,
+    client: '@hey-api/client-fetch',
     directory: './libs',
     name: 'test-api',
     plugins: [],
@@ -122,10 +122,11 @@ paths:
       const normalized = normalizeOptions(options);
 
       expect(normalized).toEqual({
-        clientType: 'fetch',
-        projectDirectory: 'test-api',
+        clientType: '@hey-api/client-fetch',
+        plugins: [],
+        projectDirectory: 'libs',
         projectName: 'test-api',
-        projectRoot: 'test-api',
+        projectRoot: 'libs/test-api',
         projectScope: '@test-api',
         specFile: tempSpecPath,
         tagArray: ['api', 'openapi'],
@@ -142,8 +143,9 @@ paths:
       const normalized = normalizeOptions(customOptions);
 
       expect(normalized).toEqual({
-        clientType: 'fetch',
-        projectDirectory: 'custom-dir/test-api',
+        clientType: '@hey-api/client-fetch',
+        plugins: [],
+        projectDirectory: 'custom-dir',
         projectName: 'test-api',
         projectRoot: 'custom-dir/test-api',
         projectScope: '@test-api',
@@ -157,7 +159,7 @@ paths:
     it('should generate project configuration', () => {
       const normalizedOptions = normalizeOptions(options);
 
-      generateNxProject({ normalizedOptions, tree });
+      generateNxProject({ clientPlugins: {}, normalizedOptions, tree });
 
       const config = readJson(
         tree,
@@ -166,14 +168,13 @@ paths:
       expect(config).toBeDefined();
       expect(config.projectType).toBe('library');
       expect(config.targets.build).toBeDefined();
-      expect(config.targets.lint).toBeDefined();
       expect(config.targets.generateApi).toBeDefined();
     });
 
     it('should generate project files', () => {
       const normalizedOptions = normalizeOptions(options);
 
-      generateNxProject({ normalizedOptions, tree });
+      generateNxProject({ clientPlugins: {}, normalizedOptions, tree });
 
       expect(
         tree.exists(`${normalizedOptions.projectRoot}/tsconfig.json`),
@@ -223,67 +224,137 @@ paths:
   });
 
   describe('updatePackageJson', () => {
-    it('should update package.json with correct dependencies', () => {
+    it('should update package.json with correct dependencies', async () => {
       const normalizedOptions = normalizeOptions(options);
-      const { clientType, projectName, projectRoot, projectScope } =
-        normalizedOptions;
+      const { projectName, projectRoot, projectScope } = normalizedOptions;
 
       // Create initial package.json
       tree.write(
         `${projectRoot}/package.json`,
         JSON.stringify({
           dependencies: {},
           devDependencies: {},
-          name: projectName,
+          name: `${projectScope}/${projectName}`,
         }),
       );
 
-      updatePackageJson({
-        clientType,
+      // Create tsconfig.base.json
+      tree.write(
+        'tsconfig.base.json',
+        JSON.stringify({
+          compilerOptions: {
+            paths: {},
+          },
+        }),
+      );
+
+      await updatePackageJson({
+        clientPlugins: {},
+        clientType: '@hey-api/client-fetch',
         projectName,
         projectRoot,
         projectScope,
         tree,
       });
 
+      // Verify tsconfig.base.json was updated
+      const tsconfig = readJson(tree, 'tsconfig.base.json');
+      expect(
+        tsconfig.compilerOptions.paths[`${projectScope}/${projectName}`],
+      ).toBeDefined();
+
       const packageJson = readJson(tree, `${projectRoot}/package.json`);
-      expect(packageJson.dependencies['@hey-api/client-fetch']).toBe('^0.9.0');
-      expect(packageJson.devDependencies['@hey-api/openapi-ts']).toBe(
-        '^0.66.0',
+      expect(packageJson.dependencies['@hey-api/client-fetch']).toBeDefined();
+    });
+
+    it('should update package.json with correct dependencies', async () => {
+      const normalizedOptions = normalizeOptions(options);
+      const { projectName, projectRoot, projectScope } = normalizedOptions;
+
+      // Create initial package.json
+      tree.write(
+        `${projectRoot}/package.json`,
+        JSON.stringify({
+          dependencies: {},
+          devDependencies: {},
+          name: `${projectScope}/${projectName}`,
+        }),
+      );
+
+      // Create tsconfig.base.json
+      tree.write(
+        'tsconfig.base.json',
+        JSON.stringify({
+          compilerOptions: {
+            paths: {},
+          },
+        }),
       );
+
+      await updatePackageJson({
+        clientPlugins: {
+          '@tanstack/react-query': {
+            tsConfigCompilerPaths: {
+              'my-test-path': './src/index.ts',
+            },
+          },
+        },
+        clientType: '@hey-api/client-fetch',
+        projectName,
+        projectRoot,
+        projectScope,
+        tree,
+      });
+
+      // Verify tsconfig.base.json was updated
+      const tsconfig = readJson(tree, 'tsconfig.base.json');
+      expect(
+        tsconfig.compilerOptions.paths[`${projectScope}/${projectName}`],
+      ).toBeDefined();
+      expect(tsconfig.compilerOptions.paths['my-test-path']).toBeDefined();
     });
 
-    it('should update package.json with axios dependencies when clientType is axios', () => {
-      const axiosOptions = {
-        ...options,
-        client: 'axios' as const,
-      } satisfies OpenApiClientGeneratorSchema;
-      const normalizedOptions = normalizeOptions(axiosOptions);
-      const { clientType, projectName, projectRoot, projectScope } =
-        normalizedOptions;
+    it('should update package.json with axios dependencies when clientType is axios', async () => {
+      const normalizedOptions = normalizeOptions(options);
+      const { projectName, projectRoot, projectScope } = normalizedOptions;
 
       // Create initial package.json
       tree.write(
         `${projectRoot}/package.json`,
         JSON.stringify({
           dependencies: {},
           devDependencies: {},
-          name: projectName,
+          name: `${projectScope}/${projectName}`,
+        }),
+      );
+
+      // Create tsconfig.base.json
+      tree.write(
+        'tsconfig.base.json',
+        JSON.stringify({
+          compilerOptions: {
+            paths: {},
+          },
         }),
       );
 
-      updatePackageJson({
-        clientType,
+      await updatePackageJson({
+        clientPlugins: {},
+        clientType: '@hey-api/client-axios',
         projectName,
         projectRoot,
         projectScope,
         tree,
       });
 
+      // Verify tsconfig.base.json was updated
+      const tsconfig = readJson(tree, 'tsconfig.base.json');
+      expect(
+        tsconfig.compilerOptions.paths[`${projectScope}/${projectName}`],
+      ).toBeDefined();
+
       const packageJson = readJson(tree, `${projectRoot}/package.json`);
-      expect(packageJson.dependencies['@hey-api/client-axios']).toBeTruthy();
-      expect(packageJson.dependencies['axios']).toBeTruthy();
-      expect(packageJson.devDependencies['@hey-api/openapi-ts']).toBeTruthy();
+      expect(packageJson.dependencies.axios).toBeDefined();
     });
   });