@squiz/dx-common-lib 1.72.0 → 1.72.1

package/src/secret-api-key-service/getSecretApiKeyService.spec.ts

@@ -0,0 +1,405 @@
+import { getSecretApiKeyService } from './getSecretApiKeyService';
+import { DevSecretApiKeyService } from './DevSecretApiKeyService';
+import { SecretApiKeyService } from './SecretApiKeyService';
+
+// Mock the util module
+jest.mock('../util', () => ({
+  getNodeEnv: jest.fn(),
+  never: jest.fn((value: never) => {
+    throw new Error(`Unexpected value: ${value}`);
+  }),
+}));
+
+// Import the mocked function
+import { getNodeEnv } from '../util';
+
+const mockGetNodeEnv = getNodeEnv as jest.MockedFunction<typeof getNodeEnv>;
+
+describe('getSecretApiKeyService', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('Development Environment', () => {
+    beforeEach(() => {
+      mockGetNodeEnv.mockReturnValue('development');
+    });
+
+    it('should return EnvApiKeyService when environment is development', () => {
+      const envVars = {
+        deploymentEnvironment: 'dev',
+        apiKey: 'test-dev-api-key',
+      };
+
+      const service = getSecretApiKeyService(envVars);
+
+      expect(service).toBeInstanceOf(DevSecretApiKeyService);
+    });
+
+    it('should pass API key to EnvApiKeyService', async () => {
+      const apiKey = 'my-dev-api-key-123';
+      const envVars = {
+        deploymentEnvironment: 'dev',
+        apiKey,
+      };
+
+      const service = getSecretApiKeyService(envVars);
+      const result = await service.getApiKey();
+
+      expect(result).toBe(apiKey);
+    });
+
+    it('should create EnvApiKeyService even when awsRegion is provided', () => {
+      const envVars = {
+        deploymentEnvironment: 'dev',
+        apiKey: 'dev-key',
+        awsRegion: 'us-east-1', // This should be ignored in dev
+        secretName: 'some-secret', // This should also be ignored
+      };
+
+      const service = getSecretApiKeyService(envVars);
+
+      expect(service).toBeInstanceOf(DevSecretApiKeyService);
+    });
+
+    it('should throw error if apiKey is empty in development', () => {
+      const envVars = {
+        deploymentEnvironment: 'dev',
+        apiKey: '',
+      };
+
+      expect(() => getSecretApiKeyService(envVars)).toThrow('API key must be a non-empty string');
+    });
+
+    it('should throw error if apiKey is undefined in development', () => {
+      const envVars = {
+        deploymentEnvironment: 'dev',
+        apiKey: undefined,
+      };
+
+      // TypeScript will complain, but at runtime this could happen
+      expect(() => getSecretApiKeyService(envVars as any)).toThrow();
+    });
+
+    it('should handle whitespace-only apiKey in development', () => {
+      const envVars = {
+        deploymentEnvironment: 'dev',
+        apiKey: '   ',
+      };
+
+      expect(() => getSecretApiKeyService(envVars)).toThrow('API key must be a non-empty string');
+    });
+  });
+
+  describe('Production Environment', () => {
+    beforeEach(() => {
+      mockGetNodeEnv.mockReturnValue('production');
+    });
+
+    it('should return SecretApiKeyService when environment is production', () => {
+      const envVars = {
+        deploymentEnvironment: 'prod',
+        secretName: 'my-secret-name',
+        awsRegion: 'us-east-1',
+      };
+
+      const service = getSecretApiKeyService(envVars);
+
+      expect(service).toBeInstanceOf(SecretApiKeyService);
+    });
+
+    it('should pass secretName and awsRegion to SecretApiKeyService', () => {
+      const secretName = '/servicekeys-prod-us/metrics-api';
+      const awsRegion = 'ap-southeast-2';
+      const envVars = {
+        deploymentEnvironment: 'prod',
+        secretName,
+        awsRegion,
+      };
+
+      const service = getSecretApiKeyService(envVars);
+
+      expect(service).toBeInstanceOf(SecretApiKeyService);
+      // We can't directly inspect the private properties, but we can verify the type
+    });
+
+    it('should create SecretApiKeyService even when apiKey is provided', () => {
+      const envVars = {
+        deploymentEnvironment: 'prod',
+        apiKey: 'some-key', // This should be ignored in prod
+        secretName: 'my-secret',
+        awsRegion: 'us-west-2',
+      };
+
+      const service = getSecretApiKeyService(envVars);
+
+      expect(service).toBeInstanceOf(SecretApiKeyService);
+    });
+
+    it('should handle production with various AWS regions', () => {
+      const regions = ['us-east-1', 'us-west-2', 'eu-west-1', 'ap-southeast-2', 'ap-northeast-1'];
+
+      regions.forEach((region) => {
+        const envVars = {
+          deploymentEnvironment: 'prod',
+          secretName: 'test-secret',
+          awsRegion: region,
+        };
+
+        const service = getSecretApiKeyService(envVars);
+        expect(service).toBeInstanceOf(SecretApiKeyService);
+      });
+    });
+
+    it('should handle production with various secret name formats', () => {
+      const secretNames = [
+        '/servicekeys-prod-us/metrics',
+        'servicekeys-dev-au/feaas-metrics',
+        'arn:aws:secretsmanager:us-east-1:123456789:secret:metrics-key',
+        'simple-secret-name',
+      ];
+
+      secretNames.forEach((secretName) => {
+        const envVars = {
+          deploymentEnvironment: 'prod',
+          secretName,
+          awsRegion: 'us-east-1',
+        };
+
+        const service = getSecretApiKeyService(envVars);
+        expect(service).toBeInstanceOf(SecretApiKeyService);
+      });
+    });
+  });
+
+  describe('Invalid Environment', () => {
+    it('should throw error for test environment', () => {
+      mockGetNodeEnv.mockReturnValue('test' as any);
+
+      const envVars = {
+        deploymentEnvironment: 'test',
+        apiKey: 'test-key',
+      };
+
+      expect(() => getSecretApiKeyService(envVars)).toThrow();
+    });
+
+    it('should throw error for staging environment', () => {
+      mockGetNodeEnv.mockReturnValue('staging' as any);
+
+      const envVars = {
+        deploymentEnvironment: 'staging',
+        apiKey: 'staging-key',
+      };
+
+      expect(() => getSecretApiKeyService(envVars)).toThrow();
+    });
+
+    it('should throw error for unknown environment', () => {
+      mockGetNodeEnv.mockReturnValue('unknown' as any);
+
+      const envVars = {
+        deploymentEnvironment: 'unknown',
+        apiKey: 'unknown-key',
+      };
+
+      expect(() => getSecretApiKeyService(envVars)).toThrow();
+    });
+
+    it('should throw error for empty string environment', () => {
+      mockGetNodeEnv.mockReturnValue('' as any);
+
+      const envVars = {
+        deploymentEnvironment: '',
+        apiKey: 'test-key',
+      };
+
+      expect(() => getSecretApiKeyService(envVars)).toThrow();
+    });
+  });
+
+  describe('Environment Variables Validation', () => {
+    it('should handle envVars with all possible fields in development', () => {
+      mockGetNodeEnv.mockReturnValue('development');
+
+      const envVars = {
+        deploymentEnvironment: 'dev',
+        apiKey: 'dev-key',
+        awsRegion: 'us-east-1',
+        secretName: 'secret-name',
+      };
+
+      const service = getSecretApiKeyService(envVars);
+      expect(service).toBeInstanceOf(DevSecretApiKeyService);
+    });
+
+    it('should handle envVars with only required fields for production', () => {
+      mockGetNodeEnv.mockReturnValue('production');
+
+      const envVars = {
+        deploymentEnvironment: 'prod',
+        secretName: 'secret-name',
+        awsRegion: 'us-east-1',
+      };
+
+      const service = getSecretApiKeyService(envVars);
+      expect(service).toBeInstanceOf(SecretApiKeyService);
+    });
+
+    it('should handle different deployment environments', () => {
+      mockGetNodeEnv.mockReturnValue('development');
+
+      const deploymentEnvs = ['dev', 'development', 'local', 'dev-au', 'dev-us'];
+
+      deploymentEnvs.forEach((deploymentEnv) => {
+        const envVars = {
+          deploymentEnvironment: deploymentEnv,
+          apiKey: 'test-key',
+        };
+
+        const service = getSecretApiKeyService(envVars);
+        expect(service).toBeInstanceOf(DevSecretApiKeyService);
+      });
+    });
+  });
+
+  describe('Real-world Scenarios', () => {
+    it('should handle local development scenario', async () => {
+      mockGetNodeEnv.mockReturnValue('development');
+
+      const envVars = {
+        deploymentEnvironment: 'dev-au',
+        apiKey: 'local-dev-metrics-api-key-12345',
+      };
+
+      const service = getSecretApiKeyService(envVars);
+      const apiKey = await service.getApiKey();
+
+      expect(service).toBeInstanceOf(DevSecretApiKeyService);
+      expect(apiKey).toBe('local-dev-metrics-api-key-12345');
+    });
+
+    it('should handle production AWS scenario', () => {
+      mockGetNodeEnv.mockReturnValue('production');
+
+      const envVars = {
+        deploymentEnvironment: 'prod-us',
+        secretName: '/servicekeys-prod-us/feaas-metrics',
+        awsRegion: 'us-east-1',
+      };
+
+      const service = getSecretApiKeyService(envVars);
+
+      expect(service).toBeInstanceOf(SecretApiKeyService);
+    });
+
+    it('should handle Australian region production scenario', () => {
+      mockGetNodeEnv.mockReturnValue('production');
+
+      const envVars = {
+        deploymentEnvironment: 'prod-au',
+        secretName: '/servicekeys-prod-au/feaas-metrics',
+        awsRegion: 'ap-southeast-2',
+      };
+
+      const service = getSecretApiKeyService(envVars);
+
+      expect(service).toBeInstanceOf(SecretApiKeyService);
+    });
+
+    it('should create different instances for different calls', () => {
+      mockGetNodeEnv.mockReturnValue('development');
+
+      const envVars1 = {
+        deploymentEnvironment: 'dev',
+        apiKey: 'key-1',
+      };
+
+      const envVars2 = {
+        deploymentEnvironment: 'dev',
+        apiKey: 'key-2',
+      };
+
+      const service1 = getSecretApiKeyService(envVars1);
+      const service2 = getSecretApiKeyService(envVars2);
+
+      // Should be different instances
+      expect(service1).not.toBe(service2);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle very long secret names in production', () => {
+      mockGetNodeEnv.mockReturnValue('production');
+
+      const envVars = {
+        deploymentEnvironment: 'prod',
+        secretName: '/very/long/secret/path/with/many/segments/'.repeat(10),
+        awsRegion: 'us-east-1',
+      };
+
+      const service = getSecretApiKeyService(envVars);
+      expect(service).toBeInstanceOf(SecretApiKeyService);
+    });
+
+    it('should handle very long API keys in development', () => {
+      mockGetNodeEnv.mockReturnValue('development');
+
+      const envVars = {
+        deploymentEnvironment: 'dev',
+        apiKey: 'x'.repeat(1000),
+      };
+
+      const service = getSecretApiKeyService(envVars);
+      expect(service).toBeInstanceOf(DevSecretApiKeyService);
+    });
+
+    it('should handle special characters in secretName', () => {
+      mockGetNodeEnv.mockReturnValue('production');
+
+      const envVars = {
+        deploymentEnvironment: 'prod',
+        secretName: '/servicekeys-prod_us/feaas.metrics-api',
+        awsRegion: 'us-east-1',
+      };
+
+      const service = getSecretApiKeyService(envVars);
+      expect(service).toBeInstanceOf(SecretApiKeyService);
+    });
+  });
+
+  describe('Type Safety', () => {
+    it('should accept all valid envVars properties', () => {
+      mockGetNodeEnv.mockReturnValue('development');
+
+      const envVars: {
+        deploymentEnvironment: string;
+        apiKey?: string;
+        awsRegion?: string | undefined;
+        secretName?: string;
+      } = {
+        deploymentEnvironment: 'dev',
+        apiKey: 'key',
+        awsRegion: undefined,
+        secretName: 'secret',
+      };
+
+      const service = getSecretApiKeyService(envVars);
+      expect(service).toBeInstanceOf(DevSecretApiKeyService);
+    });
+
+    it('should handle optional undefined properties correctly', () => {
+      mockGetNodeEnv.mockReturnValue('production');
+
+      const envVars = {
+        deploymentEnvironment: 'prod',
+        apiKey: undefined,
+        awsRegion: 'us-east-1',
+        secretName: 'secret-name',
+      };
+
+      const service = getSecretApiKeyService(envVars);
+      expect(service).toBeInstanceOf(SecretApiKeyService);
+    });
+  });
+});

package/src/secret-api-key-service/getSecretApiKeyService.ts

@@ -0,0 +1,45 @@
+/*!
+ * @file getApiKeyService.ts
+ * @description Retrieves the API key service based on the environment.
+ * @author Squiz
+ * @copyright 2025 Squiz
+ * @license MIT
+ */
+
+// Local
+import { getNodeEnv, never } from '../util';
+import { SecretApiKeyService } from './SecretApiKeyService';
+import { DevSecretApiKeyService } from './DevSecretApiKeyService';
+
+/**
+ * Retrieves the API key service based on the environment.
+ * @param envVars - The environment variables.
+ * @returns The API key service.
+ */
+export function getSecretApiKeyService(envVars: {
+  deploymentEnvironment: string;
+  apiKey?: string;
+  awsRegion?: string | undefined;
+  secretName?: string;
+}): SecretApiKeyService | DevSecretApiKeyService {
+  const env = getNodeEnv();
+
+  switch (env) {
+    // this the DX team dev environment
+    case 'development':
+      if (envVars.apiKey === undefined) {
+        throw new Error(`Need to specify 'apiKey' for development env`);
+      }
+      return new DevSecretApiKeyService(envVars.apiKey);
+    case 'production':
+      if (envVars.secretName === undefined) {
+        throw new Error(`Need to specify 'secretName' for production env`);
+      }
+      if (envVars.awsRegion === undefined) {
+        throw new Error(`Need to specify 'awsRegion' for production env`);
+      }
+      return new SecretApiKeyService(envVars.secretName, envVars.awsRegion);
+    default:
+      never(env);
+  }
+}