@sudoplatform/sudo-common 5.9.0 → 6.0.1

package/github/package.json

@@ -9,6 +9,7 @@
   "license": "Apache-2.0",
   "scripts": {
     "audit-with-suppressions": "bin/yarn-audit-with-suppression.sh",
+    "outdated-with-suppressions": "bin/yarn-outdated-with-suppression.sh",
     "clean": "rimraf ./lib ./test-lib",
     "lint": "yarn lint:eslint && yarn lint:prettier",
     "lint:eslint": "eslint \"{bin,integration-tests,src,test}/**/*.{ts,tsx}\"",
@@ -24,7 +25,9 @@
   "types": "./lib/index.d.ts",
   "bin": {
     "audit-with-suppressions": "bin/yarn-audit-with-suppression.sh",
-    "suppress-audit": "bin/suppress-audit.sh"
+    "suppress-audit": "bin/suppress-audit.sh",
+    "outdated-with-suppressions": "bin/yarn-outdated-with-suppression.sh",
+    "suppress-outdated": "bin/suppress-outdated.sh"
   },
   "files": [
     "lib",
@@ -53,23 +56,23 @@
     "@babel/preset-env": "^7.15.8",
     "@babel/preset-typescript": "^7.15.0",
     "@types/jest": "^27.0.2",
-    "@typescript-eslint/eslint-plugin": "^4.33.0",
-    "@typescript-eslint/parser": "^4.33.0",
-    "eslint": "^7.32.0",
+    "@typescript-eslint/eslint-plugin": "^5.1.0",
+    "@typescript-eslint/parser": "^5.1.0",
+    "eslint": "^8.0.1",
     "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-import": "^2.24.2",
+    "eslint-plugin-import": "^2.25.2",
     "eslint-plugin-prettier": "^4.0.0",
-    "fp-ts": "^2.11.4",
+    "fp-ts": "^2.11.5",
     "io-ts": "^2.2.16",
     "io-ts-types": "^0.5.16",
     "isomorphic-webcrypto": "^2.3.8",
-    "jest": "^27.2.4",
+    "jest": "^27.3.1",
     "monocle-ts": "^2.3.11",
     "newtype-ts": "^0.3.2",
     "prettier": "^2.4.1",
     "rimraf": "^3.0.2",
     "ts-mockito": "^2.6.1",
-    "typedoc": "^0.22.5",
-    "typescript": "^4.4.3"
+    "typedoc": "^0.22.6",
+    "typescript": "^4.4.4"
   }
-}
+}

package/github/src/errors/error.ts

@@ -16,16 +16,25 @@ export function isAppSyncNetworkError(u: Error): u is AppSyncNetworkError {
 }
 
 /**
- * Indicates the GraphQL API returned an error that's not recognized by the client.
+ * Indicates the GraphQL API returned an error that's not recognized by
+ * the client.
  */
 export class UnknownGraphQLError extends Error {
-  constructor(cause: AppSyncError) {
-    super(
-      `type: ${cause.errorType ?? '<cause type not specified>'}, message: ${
-        cause.message
-      }`,
-    )
-    this.name = 'GraphQLError'
+  constructor(cause: unknown) {
+    const maybeAppSyncError = cause as AppSyncError
+    let message: string
+    if (maybeAppSyncError?.errorType) {
+      message = `type: ${maybeAppSyncError.errorType}, message: ${maybeAppSyncError.message}`
+    } else if (maybeAppSyncError?.message) {
+      message = maybeAppSyncError?.message
+    } else if (maybeAppSyncError?.name) {
+      message = maybeAppSyncError.name
+    } else {
+      message = 'unknown cause'
+    }
+    super(message)
+
+    this.name = 'UnknownGraphQLError'
   }
 }
 

package/github/src/logging/logger.ts

@@ -4,36 +4,71 @@ import { BunyanLogger, createBunyanLogger } from './bunyanLogger'
  * Interface encapsulating logger functions.
  */
 export interface Logger {
+  /**
+   * @returns Whether or not trace level logging is enabled
+   */
+  trace(): boolean
+
   /**
    * Will log the given message with the logger implementation using the TRACE level
    * @param message the message to be logged
    * @param fields optional fields that represent an object
    */
   trace(message: string, fields?: Record<string, unknown>): void
+
+  /**
+   * @returns Whether or not debug level logging is enabled
+   */
+  debug(): boolean
+
   /**
    * Will log the given message with the logger implementation using the DEBUG level
    * @param message the message to be logged
    * @param fields optional fields that represent an object
    */
   debug(message: string, fields?: Record<string, unknown>): void
+
+  /**
+   * @returns Whether or not info level logging is enabled
+   */
+  info(): boolean
+
   /**
    * Will log the given message with the logger implementation using the INFO level
    * @param message the message to be logged
    * @param fields optional fields that represent an object
    */
   info(message: string, fields?: Record<string, unknown>): void
+
+  /**
+   * @returns Whether or not warn level logging is enabled
+   */
+  warn(): boolean
+
   /**
    * Will log the given message with the logger implementation using the WARN level
    * @param message the message to be logged
    * @param fields optional fields that represent an object
    */
   warn(message: string, fields?: Record<string, unknown>): void
+
+  /**
+   * @returns Whether or not error level logging is enabled
+   */
+  error(): boolean
+
   /**
    * Will log the given message with the logger implementation using the ERROR level
    * @param message the message to be logged
    * @param fields optional fields that represent an object
    */
   error(message: string, fields?: Record<string, unknown>): void
+
+  /**
+   * @returns Whether or not fatal level logging is enabled
+   */
+  fatal(): boolean
+
   /**
    * Will log the given message with the logger implementation using the FATAL level
    * @param message the message to be logged
@@ -55,7 +90,11 @@ export class DefaultLogger implements Logger {
     this.logger = createBunyanLogger(identifier, logLevel)
   }
 
-  trace(message: string, fields?: Record<string, unknown>): void {
+  trace(): boolean
+  trace(message: string, fields?: Record<string, unknown>): void
+  trace(message?: string, fields?: Record<string, unknown>): boolean | void {
+    if (message === undefined) return this.logger.trace()
+
     if (fields) {
       this.logger.trace({ obj: fields }, message)
     } else {
@@ -63,7 +102,11 @@ export class DefaultLogger implements Logger {
     }
   }
 
-  debug(message: string, fields?: Record<string, unknown>): void {
+  debug(): boolean
+  debug(message: string, fields?: Record<string, unknown>): void
+  debug(message?: string, fields?: Record<string, unknown>): boolean | void {
+    if (message === undefined) return this.logger.debug()
+
     if (fields) {
       this.logger.debug({ obj: fields }, message)
     } else {
@@ -71,7 +114,11 @@ export class DefaultLogger implements Logger {
     }
   }
 
-  info(message: string, fields?: Record<string, unknown>): void {
+  info(): boolean
+  info(message: string, fields?: Record<string, unknown>): void
+  info(message?: string, fields?: Record<string, unknown>): boolean | void {
+    if (message === undefined) return this.logger.info()
+
     if (fields) {
       this.logger.info({ obj: fields }, message)
     } else {
@@ -79,7 +126,11 @@ export class DefaultLogger implements Logger {
     }
   }
 
-  warn(message: string, fields?: Record<string, unknown>): void {
+  warn(): boolean
+  warn(message: string, fields?: Record<string, unknown>): void
+  warn(message?: string, fields?: Record<string, unknown>): boolean | void {
+    if (message === undefined) return this.logger.warn()
+
     if (fields) {
       this.logger.warn({ obj: fields }, message)
     } else {
@@ -87,7 +138,11 @@ export class DefaultLogger implements Logger {
     }
   }
 
-  error(message: string, fields?: Record<string, unknown>): void {
+  error(): boolean
+  error(message: string, fields?: Record<string, unknown>): void
+  error(message?: string, fields?: Record<string, unknown>): boolean | void {
+    if (message === undefined) return this.logger.error()
+
     if (fields) {
       this.logger.error({ obj: fields }, message)
     } else {
@@ -95,7 +150,11 @@ export class DefaultLogger implements Logger {
     }
   }
 
-  fatal(message: string, fields?: Record<string, unknown>): void {
+  fatal(): boolean
+  fatal(message: string, fields?: Record<string, unknown>): void
+  fatal(message?: string, fields?: Record<string, unknown>): boolean | void {
+    if (message === undefined) return this.logger.fatal()
+
     if (fields) {
       this.logger.fatal({ obj: fields }, message)
     } else {

package/github/src/sudoKeyManager/sudoCryptoProvider.ts

@@ -85,6 +85,13 @@ export interface SudoCryptoProvider {
    */
   getSymmetricKey(name: string): Promise<ArrayBuffer | undefined>
 
+  /**
+   * Checks to see if the specified symmetric key exists.
+   *
+   * @param name The name of the symmetric key.
+   */
+  doesSymmetricKeyExists(name: string): Promise<boolean>
+
   /**
    * Deletes a symmetric key from the secure store.
    *
@@ -147,6 +154,13 @@ export interface SudoCryptoProvider {
    */
   getPrivateKey(name: string): Promise<ArrayBuffer | undefined>
 
+  /**
+   * Checks to see if the specified private key exists.
+   *
+   * @param name The name of the private key.
+   */
+  doesPrivateKeyExists(name: string): Promise<boolean>
+
   /**
    * Adds a public key to the secure store.
    *

package/github/src/sudoKeyManager/sudoKeyManager.ts

@@ -63,6 +63,13 @@ export interface SudoKeyManager {
    */
   getSymmetricKey(name: string): Promise<ArrayBuffer | undefined>
 
+  /**
+   * Checks to see if the specified symmetric key exists.
+   *
+   * @param name The name of the symmetric key.
+   */
+  doesSymmetricKeyExists(name: string): Promise<boolean>
+
   /**
    * Deletes a symmetric key from the secure store.
    *
@@ -87,6 +94,13 @@ export interface SudoKeyManager {
    */
   getPrivateKey(name: string): Promise<ArrayBuffer | undefined>
 
+  /**
+   * Checks to see if the specified private key exists.
+   *
+   * @param name The name of the private key.
+   */
+  doesPrivateKeyExists(name: string): Promise<boolean>
+
   /**
    * Adds a public key to the secure store.
    *
@@ -379,6 +393,10 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     return this.sudoCryptoProvider.getSymmetricKey(name)
   }
 
+  public doesSymmetricKeyExists(name: string): Promise<boolean> {
+    return this.sudoCryptoProvider.doesSymmetricKeyExists(name)
+  }
+
   public deleteSymmetricKey(name: string): Promise<void> {
     return this.sudoCryptoProvider.deleteSymmetricKey(name)
   }
@@ -395,6 +413,10 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     return this.sudoCryptoProvider.getPrivateKey(name)
   }
 
+  public doesPrivateKeyExists(name: string): Promise<boolean> {
+    return this.sudoCryptoProvider.doesPrivateKeyExists(name)
+  }
+
   public addPublicKey(key: ArrayBuffer, name: string): Promise<void> {
     return this.sudoCryptoProvider.addPublicKey(key, name)
   }

package/github/test/logging/logger.spec.ts

@@ -57,4 +57,126 @@ describe('Logging utility test suite', () => {
       ),
     )
   })
+
+  it('should log with logger name at level set by environment variables', () => {
+    process.env.PROJECT_NAME = 'DummyProject'
+    process.env.LOG_LEVEL = 'debug'
+    const logger = new DefaultLogger()
+    console.log = jest.fn()
+    logger.debug('logger name at level set by environment variables')
+    expect(console.log).toBeCalledTimes(1)
+    expect(console.log).toBeCalledWith(
+      expect.stringContaining(
+        'DEBUG: DummyProject: logger name at level set by environment variables',
+      ),
+    )
+  })
+
+  it.each`
+    level      | traceEnabled
+    ${'trace'} | ${true}
+    ${'debug'} | ${false}
+    ${'info'}  | ${false}
+    ${'warn'}  | ${false}
+    ${'error'} | ${false}
+    ${'fatal'} | ${false}
+  `(
+    'should return trace enabled $traceEnabled when level is $level',
+    ({ level, traceEnabled }) => {
+      process.env.PROJECT_NAME = 'DummyProject'
+      process.env.LOG_LEVEL = level
+      const logger = new DefaultLogger()
+      expect(logger.trace()).toEqual(traceEnabled)
+    },
+  )
+
+  it.each`
+    level      | debugEnabled
+    ${'trace'} | ${true}
+    ${'debug'} | ${true}
+    ${'info'}  | ${false}
+    ${'warn'}  | ${false}
+    ${'error'} | ${false}
+    ${'fatal'} | ${false}
+  `(
+    'should return debug enabled $debugEnabled when level is $level',
+    ({ level, debugEnabled }) => {
+      process.env.PROJECT_NAME = 'DummyProject'
+      process.env.LOG_LEVEL = level
+      const logger = new DefaultLogger()
+      expect(logger.debug()).toEqual(debugEnabled)
+    },
+  )
+
+  it.each`
+    level      | infoEnabled
+    ${'trace'} | ${true}
+    ${'debug'} | ${true}
+    ${'info'}  | ${true}
+    ${'warn'}  | ${false}
+    ${'error'} | ${false}
+    ${'fatal'} | ${false}
+  `(
+    'should return info enabled $infoEnabled when level is $level',
+    ({ level, infoEnabled }) => {
+      process.env.PROJECT_NAME = 'DummyProject'
+      process.env.LOG_LEVEL = level
+      const logger = new DefaultLogger()
+      expect(logger.info()).toEqual(infoEnabled)
+    },
+  )
+
+  it.each`
+    level      | warnEnabled
+    ${'trace'} | ${true}
+    ${'debug'} | ${true}
+    ${'info'}  | ${true}
+    ${'warn'}  | ${true}
+    ${'error'} | ${false}
+    ${'fatal'} | ${false}
+  `(
+    'should return warn enabled $warnEnabled when level is $level',
+    ({ level, warnEnabled }) => {
+      process.env.PROJECT_NAME = 'DummyProject'
+      process.env.LOG_LEVEL = level
+      const logger = new DefaultLogger()
+      expect(logger.warn()).toEqual(warnEnabled)
+    },
+  )
+
+  it.each`
+    level      | errorEnabled
+    ${'trace'} | ${true}
+    ${'debug'} | ${true}
+    ${'info'}  | ${true}
+    ${'warn'}  | ${true}
+    ${'error'} | ${true}
+    ${'fatal'} | ${false}
+  `(
+    'should return error enabled $errorEnabled when level is $level',
+    ({ level, errorEnabled }) => {
+      process.env.PROJECT_NAME = 'DummyProject'
+      process.env.LOG_LEVEL = level
+      const logger = new DefaultLogger()
+      expect(logger.error()).toEqual(errorEnabled)
+    },
+  )
+
+  it.each`
+    level      | fatalEnabled
+    ${'trace'} | ${true}
+    ${'debug'} | ${true}
+    ${'info'}  | ${true}
+    ${'warn'}  | ${true}
+    ${'error'} | ${true}
+    ${'fatal'} | ${true}
+  `(
+    'should return fatal enabled $fatalEnabled when level is $level',
+    ({ level, fatalEnabled }) => {
+      process.env.PROJECT_NAME = 'DummyProject'
+      process.env.LOG_LEVEL = level
+      const logger = new DefaultLogger()
+      expect(logger.fatal()).toEqual(fatalEnabled)
+    },
+  )
 })

package/github/test/sudoKeyManager/sudoKeyManager.spec.ts

@@ -177,6 +177,24 @@ describe('DefaultSudoKeyManager', () => {
     })
   })
 
+  describe('doesSymmetricKeyExists', () => {
+    it('should call crypto provider doesSymmetricKeyExists', async () => {
+      when(
+        sudoCryptoProviderMock.doesSymmetricKeyExists(anything()),
+      ).thenResolve(true)
+
+      await expect(
+        sudoKeyManager.doesSymmetricKeyExists('VpnKey'),
+      ).resolves.toEqual(true)
+      const [actualKey] = capture(
+        sudoCryptoProviderMock.doesSymmetricKeyExists,
+      ).first()
+      expect(actualKey).toStrictEqual('VpnKey')
+
+      verify(sudoCryptoProviderMock.doesSymmetricKeyExists(anything())).once()
+    })
+  })
+
   describe('deleteSymmetricKey', () => {
     it('should call crypto provider deleteSymmetricKey', async () => {
       when(sudoCryptoProviderMock.deleteSymmetricKey(anything())).thenResolve()
@@ -263,6 +281,25 @@ describe('DefaultSudoKeyManager', () => {
     })
   })
 
+  describe('doesPrivateKeyExists', () => {
+    it('should call crypto provider doesPrivateKeyExists', async () => {
+      when(sudoCryptoProviderMock.doesPrivateKeyExists(anything())).thenResolve(
+        true,
+      )
+
+      await expect(
+        sudoKeyManager.doesPrivateKeyExists('VpnKeyPair'),
+      ).resolves.toBeTruthy()
+
+      const [actualKeyName] = capture(
+        sudoCryptoProviderMock.doesPrivateKeyExists,
+      ).first()
+      expect(actualKeyName).toStrictEqual('VpnKeyPair')
+
+      verify(sudoCryptoProviderMock.doesPrivateKeyExists(anything())).once()
+    })
+  })
+
   describe('addPublicKey', () => {
     it('should call crypto provider addPublicKey', async () => {
       when(