@squiz/dx-common-lib 1.39.1-alpha.2 → 1.39.1-alpha.22

package/src/api-key-validation/CloudflareApiKeyService.ts

@@ -6,15 +6,16 @@ import {
 import { UnAuthenticatedRequestError } from '../error/UnAuthenticatedRequestError';
 import { ApiKeyValidationService } from './ApiKeyValidationService';
 import { getLogger, Logger } from '@squiz/dx-logger-lib';
+import { IncomingMessage } from 'http';
 
 export interface CloudFlareKeys {
-  keys: string[];
   'matrix-keys': string[];
+  'inter-service-keys': string[];
 }
 
 let validKeys: CloudFlareKeys = {
-  keys: [],
   'matrix-keys': [],
+  'inter-service-keys': [],
 };
 
 let refreshInterval: ReturnType<typeof setInterval>;
@@ -38,20 +39,32 @@ export class CloudflareApiKeyService implements ApiKeyValidationService {
     this.logger = logger;
   }
 
-  public keyIsValid(key: string): boolean {
-    if (validKeys.keys.length == 0) {
+  /**
+   * @deprecated Suggest moving towards using JWT authentication.
+   */
+  public matrixKeyIsValid(key: string, request: IncomingMessage): boolean {
+    if (validKeys['matrix-keys'].length == 0) {
       throw new UnAuthenticatedRequestError('No api keys to check against');
     }
 
-    return validKeys.keys.includes(key);
+    if (validKeys['matrix-keys'].includes(key)) {
+      this.logger.info('Request authenticated using legacy Matrix API key', {
+        url: request.url,
+        userAgent: request.headers?.['user-agent'],
+      });
+
+      return true;
+    }
+
+    return false;
   }
 
-  public matrixKeyIsValid(key: string): boolean {
-    if (validKeys['matrix-keys'].length == 0) {
-      throw new UnAuthenticatedRequestError('No api keys to check against');
+  public interServiceKeyIsValid(key: string): boolean {
+    if (validKeys['inter-service-keys'].length == 0) {
+      throw new UnAuthenticatedRequestError('No inter service api keys to check against');
     }
 
-    return validKeys['matrix-keys'].includes(key);
+    return validKeys['inter-service-keys'].includes(key);
   }
 
   protected async getValidApiKeys(): Promise<CloudFlareKeys> {
@@ -74,7 +87,7 @@ export class CloudflareApiKeyService implements ApiKeyValidationService {
       }
       const secret = JSON.parse(secretValue.SecretString);
 
-      if (secret.keys) {
+      if (secret['matrix-keys'] && secret['inter-service-keys']) {
         return secret;
       }
 
@@ -88,7 +101,8 @@ export class CloudflareApiKeyService implements ApiKeyValidationService {
     this.logger.info('refreshing keys');
     validKeys = await this.getValidApiKeys();
 
-    this.logger.info(`number of valid keys found: ${validKeys.keys.length}`);
+    this.logger.info(`found ${validKeys['matrix-keys'].length} valid matrix keys`);
+    this.logger.info(`found ${validKeys['inter-service-keys'].length} valid inter service keys`);
 
     if (!refreshInterval) {
       refreshInterval = setInterval(async () => {
@@ -98,7 +112,7 @@ export class CloudflareApiKeyService implements ApiKeyValidationService {
   }
 
   // temporary method, to be removed when DXP auth is properly implemented
-  getMatrixKeys(): string[] {
-    return validKeys['matrix-keys'];
+  public getInterServiceKeys(): string[] {
+    return validKeys['inter-service-keys'];
   }
 }

package/src/api-key-validation/DevelopmentApiKeyService.spec.ts

@@ -1,17 +1,23 @@
 import { DevelopmentApiKeyService } from './DevelopmentApiKeyService';
+import { IncomingMessage } from 'http';
+import { getLogger } from '@squiz/dx-logger-lib';
 
 describe('DevelopmentApiKeyService', () => {
-  const service = new DevelopmentApiKeyService();
+  const service = new DevelopmentApiKeyService(getLogger({ name: 'test', silent: true }));
 
-  describe('keyIsValid', () => {
+  describe('matrixKeyIsValid', () => {
     it('should always return true', () => {
-      expect(service.keyIsValid()).toEqual(true);
+      expect(service.matrixKeyIsValid(undefined, {} as IncomingMessage)).toEqual(true);
     });
   });
 
-  describe('matrixKeyIsValid', () => {
-    it('should always return true', () => {
-      expect(service.matrixKeyIsValid()).toEqual(true);
+  describe('interServiceKeyIsValid', () => {
+    it('should return true if key is "inter-service-api-key"', () => {
+      expect(service.interServiceKeyIsValid('inter-service-api-key')).toEqual(true);
+    });
+
+    it('should return false if key is not "inter-service-api-key"', () => {
+      expect(service.interServiceKeyIsValid('invalid-api-key')).toEqual(false);
     });
   });
 });

package/src/api-key-validation/DevelopmentApiKeyService.ts

@@ -1,14 +1,25 @@
+import { getLogger, Logger } from '@squiz/dx-logger-lib';
 import { ApiKeyValidationService } from './ApiKeyValidationService';
+import { IncomingMessage } from 'http';
 
 export class DevelopmentApiKeyService implements ApiKeyValidationService {
-  public keyIsValid(): boolean {
-    return true;
+  private logger: Logger;
+
+  public constructor(logger?: Logger) {
+    this.logger = logger || getLogger({ name: 'DevelopmentApiKeyService' });
   }
-  public matrixKeyIsValid(): boolean {
+  public matrixKeyIsValid(key: string | undefined, request: IncomingMessage): boolean {
+    this.logger.info('Request authenticated using legacy Matrix API key', {
+      url: request.url,
+      userAgent: request.headers?.['user-agent'],
+    });
     return true;
   }
+  public interServiceKeyIsValid(key: string | undefined): boolean {
+    return Boolean(key && this.getInterServiceKeys().includes(key));
+  }
   // temporary method, to be removed when DXP auth is properly implemented
-  getMatrixKeys(): string[] {
-    return ['matrix-api-key'];
+  public getInterServiceKeys(): string[] {
+    return ['inter-service-api-key'];
   }
 }

package/src/index.ts

@@ -8,7 +8,6 @@ export * from './api-key-validation/ApiKeyValidationService';
 export * from './api-key-validation/CloudflareApiKeyService';
 export * from './api-key-validation/DevelopmentApiKeyService';
 export * from './api-key-validation/getApiKeyService';
-export * from './server-utils/apiKeyMiddleware';
 export * from './cache';
 export * from './formatted-text/formattedTextToHtmlString';
 export * from './json-order';