feat: SSMProvider.getMultiple

dreamorosi · dreamorosi · commit e772d2319ede · 2022-12-15T16:23:49.000+01:00
diff --git a/packages/parameters/src/BaseProvider.ts b/packages/parameters/src/BaseProvider.ts
@@ -5,8 +5,8 @@ import { ExpirableValue } from './ExpirableValue';
 import { TRANSFORM_METHOD_BINARY, TRANSFORM_METHOD_JSON } from './constants';
 import { GetParameterError, TransformParameterError } from './Exceptions';
 import type { BaseProviderInterface, GetMultipleOptionsInterface, GetOptionsInterface, TransformOptions } from './types';
-import { isSSMGetOptionsInterface } from './types/SSMProvider';
-import type { SSMGetOptionsInterface } from './types/SSMProvider';
+import { isSSMGetOptionsInterface, isSSMGetMultipleOptionsInterface } from './types/SSMProvider';
+import type { SSMGetOptionsInterface, SSMGetMultipleOptionsInterface } from './types/SSMProvider';
 
 // These providers will be dynamically initialized on first use of the helper functions
 const DEFAULT_PROVIDERS: { [key: string]: BaseProvider } = {};
@@ -77,6 +77,7 @@ abstract class BaseProvider implements BaseProviderInterface {
     return value;
   }
 
+  public async getMultiple(path: string, options?: SSMGetMultipleOptionsInterface): Promise<undefined | Record<string, unknown>>;
   public async getMultiple(path: string, options?: GetMultipleOptionsInterface): Promise<undefined | Record<string, unknown>> {
     const configs = new GetMultipleOptions(options || {});
     const key = [ path, configs.transform ].toString();
@@ -89,6 +90,12 @@ abstract class BaseProvider implements BaseProviderInterface {
 
     let values: Record<string, unknown> = {};
     try {
+      // Type assertion is needed because the SSM provider has a different signature for the get method
+      if (options && isSSMGetMultipleOptionsInterface(options)) {
+        options.sdkOptions = options.sdkOptions || {};
+        if (options.hasOwnProperty('decrypt')) options.sdkOptions.WithDecryption = options.decrypt;
+        if (options.hasOwnProperty('recursive')) options.sdkOptions.Recursive = options.recursive;
+      }
       values = await this._getMultiple(path, options?.sdkOptions);
     } catch (error) {
       throw new GetParameterError((error as Error).message);
diff --git a/packages/parameters/src/SSMProvider.ts b/packages/parameters/src/SSMProvider.ts
@@ -1,7 +1,8 @@
 import { BaseProvider, DEFAULT_PROVIDERS } from './BaseProvider';
-import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm';
-import type { SSMClientConfig, GetParameterCommandInput } from '@aws-sdk/client-ssm';
+import { SSMClient, GetParameterCommand, paginateGetParametersByPath } from '@aws-sdk/client-ssm';
+import type { SSMClientConfig, GetParameterCommandInput, GetParametersByPathCommandInput } from '@aws-sdk/client-ssm';
 import type { SSMGetOptionsInterface } from 'types/SSMProvider';
+import { PaginationConfiguration } from '@aws-sdk/types';
 
 class SSMProvider extends BaseProvider {
   public client: SSMClient;
@@ -23,8 +24,42 @@ class SSMProvider extends BaseProvider {
     return result.Parameter?.Value;
   }
 
-  protected _getMultiple(_path: string): Promise<Record<string, string | undefined>> {
-    throw Error('Not implemented.');
+  protected async _getMultiple(path: string, sdkOptions?: Partial<GetParametersByPathCommandInput>): Promise<Record<string, string | undefined>> {
+    const options: GetParametersByPathCommandInput = {
+      Path: path,
+    };
+    const paginationOptions: PaginationConfiguration = {
+      client: this.client
+    };
+    if (sdkOptions) {
+      Object.assign(options, sdkOptions);
+      if (sdkOptions.MaxResults) {
+        paginationOptions.pageSize = sdkOptions.MaxResults;
+      }
+    }
+
+    const parameters: Record<string, string | undefined> = {};
+    for await (const page of paginateGetParametersByPath(paginationOptions, options)) {
+      for (const parameter of page.Parameters || []) {
+        /**
+         * Standardize the parameter name
+         *
+         * The parameter name returned by SSM will contain the full path.
+         * However, for readability, we should return only the part after the path. 
+         **/ 
+        
+        // If the parameter is present in the response, then it has a Name
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        let name = parameter.Name!;
+        name = name.replace(path, '');
+        if (name.startsWith('/')) {
+          name = name.replace('/', '');
+        }
+        parameters[name] = parameter.Value;
+      }
+    }
+
+    return parameters;
   }
 }
 
diff --git a/packages/parameters/src/types/SSMProvider.ts b/packages/parameters/src/types/SSMProvider.ts
@@ -1,4 +1,4 @@
-import type { GetParameterCommandInput } from '@aws-sdk/client-ssm';
+import type { GetParameterCommandInput, GetParametersByPathCommandInput } from '@aws-sdk/client-ssm';
 import type { TransformOptions } from 'types/BaseProvider';
 
 /**
@@ -19,7 +19,24 @@ interface SSMGetOptionsInterface {
 
 const isSSMGetOptionsInterface = (options: unknown): options is SSMGetOptionsInterface => (options as SSMGetOptionsInterface).decrypt !== undefined;
 
+interface SSMGetMultipleOptionsInterface {
+  maxAge?: number
+  forceFetch?: boolean
+  sdkOptions?: Partial<GetParametersByPathCommandInput>
+  decrypt?: boolean
+  recursive?: boolean
+  transform?: string
+  throwOnTransformError?: boolean
+}
+
+const isSSMGetMultipleOptionsInterface = 
+  (options: unknown): options is SSMGetMultipleOptionsInterface => 
+    (options as SSMGetMultipleOptionsInterface).decrypt !== undefined || 
+    (options as SSMGetMultipleOptionsInterface).recursive !== undefined;
+
 export {
   SSMGetOptionsInterface,
   isSSMGetOptionsInterface,
+  SSMGetMultipleOptionsInterface,
+  isSSMGetMultipleOptionsInterface,
 };
diff --git a/packages/parameters/tests/unit/SSMProvider.test.ts b/packages/parameters/tests/unit/SSMProvider.test.ts
@@ -4,7 +4,7 @@
  * @group unit/parameters/SSMProvider/class
  */
 import { SSMProvider } from '../../src/SSMProvider';
-import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm';
+import { SSMClient, GetParameterCommand, GetParametersByPathCommand } from '@aws-sdk/client-ssm';
 import { mockClient } from 'aws-sdk-client-mock';
 import 'aws-sdk-client-mock-jest';
  
@@ -14,7 +14,7 @@ describe('Class: SSMProvider', () => {
     jest.clearAllMocks();
   });
 
-  describe('Method: get', () => {
+  describe('Method: _get', () => {
 
     test('when called without sdkOptions, it gets the parameter using the name and with no decryption', async () => {
 
@@ -47,7 +47,7 @@ describe('Class: SSMProvider', () => {
       const parameterName = 'foo';
 
       // Act
-      provider.get(parameterName, { sdkOptions: { WithDecryption: true } });
+      await provider.get(parameterName, { sdkOptions: { WithDecryption: true } });
 
       // Assess
       expect(client).toReceiveCommandWith(GetParameterCommand, {
@@ -65,7 +65,7 @@ describe('Class: SSMProvider', () => {
       const parameterName = 'foo';
 
       // Act
-      provider.get(parameterName, { decrypt: true });
+      await provider.get(parameterName, { decrypt: true });
 
       // Assess
       expect(client).toReceiveCommandWith(GetParameterCommand, {
@@ -79,13 +79,142 @@ describe('Class: SSMProvider', () => {
 
   describe('Method: _getMultiple', () => {
 
-    test('when called throws', async () => {
+    test('when called with only a path, it passes it to the sdk', async () => {
 
       // Prepare
       const provider = new SSMProvider();
+      const client = mockClient(SSMClient).on(GetParametersByPathCommand)
+        .resolves({});
+      const parameterPath = '/foo';
 
-      // Act / Assess
-      expect(provider.getMultiple('foo')).rejects.toThrow('Not implemented.');
+      // Act
+      await provider.getMultiple(parameterPath);
+      
+      // Assess
+      expect(client).toReceiveCommandWith(GetParametersByPathCommand, {
+        Path: parameterPath,
+      });
+
+    });
+
+    test('when called with a path and sdkOptions, it passes them to the sdk', async () => {
+
+      // Prepare
+      const provider = new SSMProvider();
+      const client = mockClient(SSMClient).on(GetParametersByPathCommand)
+        .resolves({
+          Parameters: []
+        });
+      const parameterPath = '/foo';
+
+      // Act
+      await provider.getMultiple(parameterPath, { sdkOptions: { MaxResults: 10 } });
+      
+      // Assess
+      expect(client).toReceiveCommandWith(GetParametersByPathCommand, {
+        Path: parameterPath,
+        MaxResults: 10,
+      });
+
+    });
+
+    test('when called with no options, it uses the default sdk options', async () => {
+
+      // Prepare
+      const provider = new SSMProvider();
+      const client = mockClient(SSMClient).on(GetParametersByPathCommand)
+        .resolves({
+          Parameters: []
+        });
+      const parameterPath = '/foo';
+
+      // Act
+      await provider.getMultiple(parameterPath);
+      
+      // Assess
+      expect(client).toReceiveCommandWith(GetParametersByPathCommand, {
+        Path: parameterPath,
+      });
+
+    });
+    
+    test('when called with decrypt or recursive, it passes them to the sdk', async () => {
+
+      // Prepare
+      const provider = new SSMProvider();
+      const client = mockClient(SSMClient).on(GetParametersByPathCommand)
+        .resolves({
+          Parameters: []
+        });
+      const parameterPath = '/foo';
+
+      // Act
+      await provider.getMultiple(parameterPath, { recursive: false, decrypt: true });
+      
+      // Assess
+      expect(client).toReceiveCommandWith(GetParametersByPathCommand, {
+        Path: parameterPath,
+        Recursive: false,
+        WithDecryption: true,
+      });
+
+    });
+    
+    test('when multiple parameters that share the same path as suffix are retrieved, it returns an object with the names only', async () => {
+
+      // Prepare
+      const provider = new SSMProvider();
+      mockClient(SSMClient).on(GetParametersByPathCommand)
+        .resolves({
+          Parameters: [ {
+            'Name':'/foo/bar',
+            'Value':'bar',
+          }, {
+            'Name':'/foo/baz',
+            'Value':'baz',
+          } ]
+        });
+      const parameterPath = '/foo';
+
+      // Act
+      const parameters = await provider.getMultiple(parameterPath);
+      
+      // Assess
+      expect(parameters).toEqual({
+        'bar': 'bar',
+        'baz': 'baz',
+      });
+
+    });
+
+    test('when multiple pages are found, it returns an object with all the parameters', async () => {
+
+      // Prepare
+      const provider = new SSMProvider();
+      mockClient(SSMClient).on(GetParametersByPathCommand)
+        .resolvesOnce({
+          Parameters: [{
+            'Name':'/foo/bar',
+            'Value':'bar',
+          }],
+          NextToken: 'someToken',
+        })
+        .resolves({
+          Parameters: [{
+            'Name':'/foo/baz',
+            'Value':'baz',
+          }]
+        });
+      const parameterPath = '/foo';
+
+      // Act
+      const parameters = await provider.getMultiple(parameterPath);
+      
+      // Assess
+      expect(parameters).toEqual({
+        'bar': 'bar',
+        'baz': 'baz',
+      });
 
     });
 
