@aligent/nx-openapi 2.0.1 → 2.1.0

package/README.md

@@ -24,6 +24,11 @@ Run `nx g @aligent/nx-openapi:client` with optional flags:
 - `--configPath` path to the redocly config file responsible for authentication when fetching a schema remotely. For more information: https://openapi-ts.dev/cli#auth.
 - `--skipValidate` If passed, this will skip schema pre-validation. Only do this if you have good reason to - not validating the schema beforehand may produce unpredictable results (either things may not generate at all or they may generate something that is incorrect).
 - `--override` Override the schema (and the generated type) of an existing client.
+- `--authMethod` Authentication method for the generated client middleware. Defaults to `api-key`. Available options:
+  - `api-key` - API key authentication using SSM Parameter Store
+  - `oauth1.0a` - OAuth 1.0a authentication
+  - `basic` - Basic authentication (username/password)
+  - `oauth2.0` - OAuth 2.0 token-based authentication
 
 **:rotating_light: Do not edit the files in the `/generated` folder after generating a client. These files are generated using the OpenAPI Schema and editing them may put you at risk of no longer conforming to the specifications of the API you are using! :rotating_light:**
 
@@ -73,4 +78,9 @@ A `types` file that will contain several typescript interfaces depending on the
 - `operations`: The defined operations that can be performed on a given path. [More information.](https://swagger.io/docs/specification/v3_0/paths-and-operations/#operations)
 - `components`: A way of avoid duplication when paths or operations contain the same structure in their responses. Components define a structure that is used multiple time throughout the API. [More information.](https://swagger.io/docs/specification/v3_0/components/)
 
-A `client` file that will contain some commented, boilerplate code to help you get started.
+A `client` file that will contain boilerplate code to help you get started. The client includes authentication middleware configured based on the `--authMethod` flag:
+
+- **api-key**: Configured to fetch credentials from AWS SSM Parameter Store
+- **oauth1.0a**: Configured with HMAC-SHA256 algorithm and placeholder credentials
+- **basic**: Configured with placeholder username/password credentials
+- **oauth2.0**: Configured with placeholder token and Bearer token type

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aligent/nx-openapi",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "type": "commonjs",
   "main": "./src/index.js",
   "typings": "./src/index.d.ts",
@@ -10,9 +10,10 @@
     "directory": "packages/nx-openapi"
   },
   "dependencies": {
-    "@nx/devkit": "22.4.1",
+    "@nx/devkit": "22.4.2",
     "@redocly/openapi-core": "^1.34.2",
     "openapi-typescript": "7.7.3",
+    "ts-morph": "^27.0.2",
     "typescript": "^5.9.3"
   },
   "generators": "./generators.json",

package/src/generators/client/client-specific-files/client.ts.template

@@ -6,18 +6,15 @@
  * - For more information about openapi-fetch middlewares: https://openapi-ts.dev/openapi-fetch/middleware-auth#middleware
  */
 import {
-    apiKeyAuthMiddleware,
-    fetchSsmParams,
     retryMiddleware,
 } from '@aligent/microservice-util-lib';
 import createClient, { Client, ClientOptions } from 'openapi-fetch';
 import { paths } from './generated-types';
 
 export class <%= className %> {
-    private credential: string | null = null;
     public readonly client: Client<paths, `${string}/${string}`>;
 
-    constructor(options: ClientOptions, credentialPath: string) {
+    constructor(options: ClientOptions) {
         this.client = createClient<paths>(options);
 
         /**
@@ -25,23 +22,6 @@ export class <%= className %> {
          * - For requests, onRequest() will be called in the order registered
          * - For responses, onResponse() will be called in reverse order.
          */
-        this.client.use(
-            apiKeyAuthMiddleware({
-                header: 'Authorization',
-                value: async () => {
-                    if (!this.credential) {
-                        const param = await fetchSsmParams(credentialPath);
-                        if (!param?.Value) {
-                            throw new Error('Unable to fetch API client credential');
-                        }
-
-                        this.credential = param.Value;
-                    }
-
-                    return `Bearer ${this.credential}`;
-                },
-            })
-        );
 
         this.client.use(
             retryMiddleware({

package/src/generators/client/generator.js

@@ -4,11 +4,12 @@ exports.clientGenerator = clientGenerator;
 const devkit_1 = require("@nx/devkit");
 const generate_openapi_types_1 = require("../../helpers/generate-openapi-types");
 const utilities_1 = require("../../helpers/utilities");
+const auth_configurations_1 = require("./helpers/auth-configurations");
 const VALID_EXTENSIONS = ['yaml', 'yml', 'json'];
 // We also use this as the project root for all generated clients
 const PROJECT_NAME = 'clients';
 async function clientGenerator(tree, options) {
-    const { name, schemaPath, importPath = `@clients`, skipValidate, override } = options;
+    const { name, schemaPath, importPath = `@clients`, skipValidate, override, authMethod = 'api-key', } = options;
     const ext = schemaPath.split('.').pop() || '';
     if (!VALID_EXTENSIONS.includes(ext)) {
         throw new Error(`Invalid schema file extension: ${ext}`);
@@ -43,9 +44,13 @@ async function clientGenerator(tree, options) {
      * Each time we add new API client, we actually add a new class into `clients` project (if it exists).
      * This add a new example client class to `apiClientDest` folder
      */
+    const className = (0, utilities_1.toClassName)(name);
     (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, './client-specific-files'), apiClientDest, {
-        className: (0, utilities_1.toClassName)(name),
+        className,
     });
+    // Apply auth method configuration using ts-morph
+    const clientFilePath = (0, devkit_1.joinPathFragments)(apiClientDest, 'client.ts');
+    (0, auth_configurations_1.applyAuthMethodConfiguration)(tree, clientFilePath, authMethod, className);
     /**
      * The `clients` project expose all the API clients via `src/index.ts` file.
      * As a result, we need to append new client to the list of exporting;

package/src/generators/client/helpers/auth-configurations.d.ts

@@ -0,0 +1,24 @@
+import { Tree } from '@nx/devkit';
+interface MiddlewareConfig {
+    properties: string;
+}
+interface AuthMethodConfig {
+    middlewareName: string;
+    extraImports: string[];
+    classProperty: string | null;
+    constructorParam: string | null;
+    middlewareConfig: MiddlewareConfig;
+}
+export declare const AUTH_CONFIGS: Record<string, AuthMethodConfig>;
+/**
+ * Applies auth method configuration to a generated client file using ts-morph.
+ * This modifies the file in the Nx Tree to add auth-specific imports, properties,
+ * constructor parameters, and middleware configuration.
+ *
+ * @param tree - The Nx virtual file system tree
+ * @param filePath - Path to the client.ts file in the tree
+ * @param authMethod - The auth method to apply
+ * @param className - The name of the client class
+ */
+export declare function applyAuthMethodConfiguration(tree: Tree, filePath: string, authMethod: string, className: string): void;
+export {};

package/src/generators/client/helpers/auth-configurations.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTH_CONFIGS = void 0;
+exports.applyAuthMethodConfiguration = applyAuthMethodConfiguration;
+const ts_morph_1 = require("ts-morph");
+exports.AUTH_CONFIGS = {
+    'api-key': {
+        middlewareName: 'apiKeyAuthMiddleware',
+        extraImports: ['fetchSsmParams'],
+        classProperty: 'private credential: string | null = null;',
+        constructorParam: 'credentialPath: string',
+        middlewareConfig: {
+            properties: `header: 'X-Api-Key',
+                value: async () => {
+                    if (!this.credential) {
+                        const param = await fetchSsmParams(credentialPath);
+                        if (!param?.Value) {
+                            throw new Error('Unable to fetch API client credential');
+                        }
+
+                        this.credential = param.Value;
+                    }
+
+                    return this.credential;
+                },`,
+        },
+    },
+    'oauth1.0a': {
+        middlewareName: 'oAuth10aAuthMiddleware',
+        extraImports: [],
+        classProperty: null,
+        constructorParam: null,
+        middlewareConfig: {
+            properties: `algorithm: 'HMAC-SHA256',
+                credentials: async () => ({
+                    // TODO: Provide your OAuth 1.0a credentials
+                    consumerKey: 'your-consumer-key',
+                    consumerSecret: 'your-consumer-secret',
+                    token: 'your-token',
+                    tokenSecret: 'your-token-secret',
+                }),`,
+        },
+    },
+    basic: {
+        middlewareName: 'basicAuthMiddleware',
+        extraImports: [],
+        classProperty: null,
+        constructorParam: null,
+        middlewareConfig: {
+            properties: `credentials: async () => ({
+                    // TODO: Provide your basic auth credentials
+                    username: 'your-username',
+                    password: 'your-password',
+                }),`,
+        },
+    },
+    'oauth2.0': {
+        middlewareName: 'oAuth20AuthMiddleware',
+        extraImports: [],
+        classProperty: null,
+        constructorParam: null,
+        middlewareConfig: {
+            properties: `token: async () => {
+                    // TODO: Send API call to get your OAuth 2.0 access token
+                    return 'your-access-token';
+                }`,
+        },
+    },
+};
+/**
+ * Applies auth method configuration to a generated client file using ts-morph.
+ * This modifies the file in the Nx Tree to add auth-specific imports, properties,
+ * constructor parameters, and middleware configuration.
+ *
+ * @param tree - The Nx virtual file system tree
+ * @param filePath - Path to the client.ts file in the tree
+ * @param authMethod - The auth method to apply
+ * @param className - The name of the client class
+ */
+function applyAuthMethodConfiguration(tree, filePath, authMethod, className) {
+    const config = exports.AUTH_CONFIGS[authMethod];
+    if (!config) {
+        throw new Error(`Unknown auth method: ${authMethod}`);
+    }
+    const fileContent = tree.read(filePath, 'utf-8');
+    if (!fileContent) {
+        throw new Error(`Unable to read file: ${filePath}`);
+    }
+    const project = new ts_morph_1.Project({
+        useInMemoryFileSystem: true,
+        manipulationSettings: {
+            indentationText: ts_morph_1.IndentationText.FourSpaces,
+            quoteKind: ts_morph_1.QuoteKind.Single,
+        },
+    });
+    const sourceFile = project.createSourceFile(filePath, fileContent);
+    // Add imports to the @aligent/microservice-util-lib import declaration
+    const utilLibImport = sourceFile.getImportDeclaration(decl => decl.getModuleSpecifierValue() === '@aligent/microservice-util-lib');
+    if (utilLibImport) {
+        for (const importName of config.extraImports) {
+            utilLibImport.addNamedImport(importName);
+        }
+        utilLibImport.addNamedImport(config.middlewareName);
+    }
+    // Get the client class
+    const clientClass = sourceFile.getClass(className);
+    if (!clientClass) {
+        throw new Error(`Unable to find class: ${className}`);
+    }
+    // Add class property if configured (insert before the 'client' property)
+    if (config.classProperty) {
+        const clientProperty = clientClass.getProperty('client');
+        if (clientProperty) {
+            const propertyIndex = clientProperty.getChildIndex();
+            clientClass.insertProperty(propertyIndex, {
+                name: 'credential',
+                type: 'string | null',
+                initializer: 'null',
+                scope: ts_morph_1.Scope.Private,
+            });
+        }
+    }
+    // Modify constructor to add parameter and middleware
+    const constructor = clientClass.getConstructors()[0];
+    if (!constructor) {
+        throw new Error(`Unable to find constructor in class: ${className}`);
+    }
+    // Add constructor parameter if configured
+    if (config.constructorParam) {
+        const parts = config.constructorParam.split(':');
+        const paramName = parts[0]?.trim() ?? '';
+        const paramType = parts[1]?.trim() ?? '';
+        constructor.addParameter({
+            name: paramName,
+            type: paramType,
+        });
+    }
+    // Build the middleware call
+    const middlewareCall = `this.client.use(
+            ${config.middlewareName}({
+                ${config.middlewareConfig.properties}
+            })
+        );`;
+    // Find the retryMiddleware use statement and insert before it
+    const statements = constructor.getStatements();
+    const retryStatementIndex = statements.findIndex(statement => /this\.client\.use\(\s*retryMiddleware/.test(statement.getText()));
+    if (retryStatementIndex !== -1) {
+        constructor.insertStatements(retryStatementIndex, middlewareCall);
+    }
+    // Write the modified content back to the tree
+    tree.write(filePath, sourceFile.getFullText());
+}

package/src/generators/client/schema.d.ts

@@ -5,4 +5,5 @@ export interface ClientGeneratorSchema {
     importPath?: string;
     skipValidate: boolean;
     override: boolean;
+    authMethod?: string;
 }

package/src/generators/client/schema.json

@@ -40,6 +40,12 @@
             "type": "boolean",
             "description": "Override existing files during generation",
             "default": false
+        },
+        "authMethod": {
+            "type": "string",
+            "description": "Authentication method to use for the generated client middleware",
+            "enum": ["api-key", "oauth1.0a", "basic", "oauth2.0"],
+            "default": "api-key"
         }
     },
     "required": ["name", "schemaPath"]