@creator.co/wapi 1.2.2 → 1.2.3

package/tests/Config/Config.test.ts

@@ -1,62 +1,62 @@
-import { SSMClient, GetParameterCommand } from "@aws-sdk/client-ssm"
-import { mockClient } from "aws-sdk-client-mock"
-import { expect } from "chai"
+import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm'
+import { mockClient } from 'aws-sdk-client-mock'
+import { expect } from 'chai'
 
-import Configuration from "../../src/Config/Configuration"
-import { SampleConfig, SampleConfigSchema } from "../Test.utils"
+import Configuration from '../../src/Config/Configuration'
+import { SampleConfig, SampleConfigSchema } from '../Test.utils'
 
 const SSMMock = mockClient(SSMClient)
-const config = new Configuration<SampleConfigSchema>(SampleConfig, "my-prefix")
+const config = new Configuration<SampleConfigSchema>(SampleConfig, 'my-prefix')
 describe(`Optional remote environment`, () => {
   // reset mock
   beforeEach(() => {
     SSMMock.reset()
-    config["resetCache"]()
+    config['resetCache']()
   })
 
-  test("Does not accept sync get", async () => {
+  test('Does not accept sync get', async () => {
     let err = null
     try {
       // @ts-ignore
-      config.get("TOKEN_SECRET")
+      config.get('TOKEN_SECRET')
     } catch (e) {
       err = e
     }
     expect(err).is.not.null
-    expect(err?.["message"]).is.not.null
+    expect(err?.['message']).is.not.null
   })
 
-  test("Optional value with null value", async () => {
+  test('Optional value with null value', async () => {
     SSMMock.on(GetParameterCommand).resolves({
       Parameter: {
         Value: undefined,
       },
     })
-    const token = await config.asyncGet("TOKEN_SECRET_FALSY")
+    const token = await config.asyncGet('TOKEN_SECRET_FALSY')
     expect(token).is.undefined
   })
 
-  test("Optional value with empty response", async () => {
+  test('Optional value with empty response', async () => {
     SSMMock.on(GetParameterCommand).resolves({})
-    const token = await config.asyncGet("TOKEN_SECRET_FALSY")
+    const token = await config.asyncGet('TOKEN_SECRET_FALSY')
     expect(token).is.undefined
   })
 
-  test("Optional value with valid response", async () => {
-    const value = "abc"
+  test('Optional value with valid response', async () => {
+    const value = 'abc'
     SSMMock.on(GetParameterCommand).resolves({
       Parameter: {
         Value: value,
       },
     })
-    const token = await config.asyncGet("TOKEN_SECRET_FALSY")
+    const token = await config.asyncGet('TOKEN_SECRET_FALSY')
     expect(token).is.not.undefined
     expect(token).to.be.equals(value)
   })
 
-  test("Optional value rejection", async () => {
-    SSMMock.on(GetParameterCommand).rejects(new Error("failed!"))
-    const token = await config.asyncGet("TOKEN_SECRET_FALSY")
+  test('Optional value rejection', async () => {
+    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
+    const token = await config.asyncGet('TOKEN_SECRET_FALSY')
     expect(token).is.undefined
   })
 })
@@ -65,22 +65,22 @@ describe(`Required remote environment`, () => {
   // reset mock
   beforeEach(() => {
     SSMMock.reset()
-    config["resetCache"]()
+    config['resetCache']()
   })
 
-  test("Does not accept sync get", async () => {
+  test('Does not accept sync get', async () => {
     let err = null
     try {
       // @ts-ignore
-      config.get("TOKEN_SECRET")
+      config.get('TOKEN_SECRET')
     } catch (e) {
       err = e
     }
     expect(err).is.not.null
-    expect(err?.["message"]).is.not.null
+    expect(err?.['message']).is.not.null
   })
 
-  test("Required value with null value", async () => {
+  test('Required value with null value', async () => {
     SSMMock.on(GetParameterCommand).resolves({
       Parameter: {
         Value: undefined,
@@ -88,80 +88,80 @@ describe(`Required remote environment`, () => {
     })
     let err = null
     try {
-      await config.asyncGet("TOKEN_SECRET")
+      await config.asyncGet('TOKEN_SECRET')
     } catch (e) {
       err = e
     }
     expect(err).is.not.null
-    expect(err?.["message"]).is.not.null
+    expect(err?.['message']).is.not.null
   })
 
-  test("Required value with empty response", async () => {
+  test('Required value with empty response', async () => {
     SSMMock.on(GetParameterCommand).resolves({})
     let err = null
     try {
-      await config.asyncGet("TOKEN_SECRET")
+      await config.asyncGet('TOKEN_SECRET')
     } catch (e) {
       err = e
     }
     expect(err).is.not.null
-    expect(err?.["message"]).is.not.null
+    expect(err?.['message']).is.not.null
   })
 
-  test("Required value with valid response", async () => {
-    const value = "abc"
+  test('Required value with valid response', async () => {
+    const value = 'abc'
     SSMMock.on(GetParameterCommand).resolves({
       Parameter: {
         Value: value,
       },
     })
-    const token = await config.asyncGet("TOKEN_SECRET")
+    const token = await config.asyncGet('TOKEN_SECRET')
     expect(token).is.not.undefined
     expect(token).to.be.equals(value)
   })
 
-  test("Required value rejection", async () => {
-    SSMMock.on(GetParameterCommand).rejects(new Error("failed!"))
+  test('Required value rejection', async () => {
+    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
     let err = null
     try {
-      await config.asyncGet("TOKEN_SECRET")
+      await config.asyncGet('TOKEN_SECRET')
     } catch (e) {
       err = e
     }
     expect(err).is.not.null
-    expect(err?.["message"]).is.not.null
+    expect(err?.['message']).is.not.null
   })
 })
 
 describe(`Optional local environment`, () => {
   beforeEach(() => {
-    config["resetCache"]()
+    config['resetCache']()
   })
 
-  test("Optional value with null value", async () => {
-    const token = config.get("PATH123")
+  test('Optional value with null value', async () => {
+    const token = config.get('PATH123')
     expect(token).is.undefined
   })
 })
 
 describe(`Required local environment`, () => {
   beforeEach(() => {
-    config["resetCache"]()
+    config['resetCache']()
   })
 
-  test("Required value with null value", async () => {
+  test('Required value with null value', async () => {
     let err = null
     try {
-      config.get("PATH_FALSY")
+      config.get('PATH_FALSY')
     } catch (e) {
       err = e
     }
     expect(err).is.not.null
-    expect(err?.["message"]).is.not.null
+    expect(err?.['message']).is.not.null
   })
 
-  test("Required value with valid response", async () => {
-    const key = "PATH"
+  test('Required value with valid response', async () => {
+    const key = 'PATH'
     const v = config.get(key)
     expect(v).is.not.null
     expect(v).to.be.equals(process.env[key])
@@ -169,9 +169,9 @@ describe(`Required local environment`, () => {
 })
 
 describe(`Caching test`, () => {
-  test("Does cache previous fetched value", async () => {
-    const value = "123"
-    const key = "TOKEN_SECRET"
+  test('Does cache previous fetched value', async () => {
+    const value = '123'
+    const key = 'TOKEN_SECRET'
     // initial fetch
     SSMMock.on(GetParameterCommand).resolves({
       Parameter: {
@@ -183,7 +183,7 @@ describe(`Caching test`, () => {
     expect(v).to.be.equals(value)
     // subsequent fetch
     SSMMock.reset()
-    SSMMock.on(GetParameterCommand).rejects(new Error("failed!"))
+    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
     const v2 = await config.asyncGet(key)
     expect(v2).is.not.null
     expect(v2).to.be.equals(value)

package/tests/Config/EnvironmentVar.test.ts

@@ -1,14 +1,9 @@
-import {
-  SecretsManagerClient,
-  GetSecretValueCommand,
-} from "@aws-sdk/client-secrets-manager"
-import { SSMClient, GetParameterCommand } from "@aws-sdk/client-ssm"
-import { mockClient } from "aws-sdk-client-mock"
-import { expect } from "chai"
-
-import EnvironmentVar, {
-  EnvironmentType,
-} from "../../src/Config/EnvironmentVar"
+import { SecretsManagerClient, GetSecretValueCommand } from '@aws-sdk/client-secrets-manager'
+import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm'
+import { mockClient } from 'aws-sdk-client-mock'
+import { expect } from 'chai'
+
+import EnvironmentVar, { EnvironmentType } from '../../src/Config/EnvironmentVar'
 
 const SSMMock = mockClient(SSMClient)
 const SecretsManagerMock = mockClient(SecretsManagerClient)
@@ -20,7 +15,7 @@ function testRemoteEnv(mock, type, command) {
       mock.reset()
     })
 
-    test("Does not accept sync resolve", async () => {
+    test('Does not accept sync resolve', async () => {
       mock.on(command).resolves({
         Parameter: {
           Value: undefined,
@@ -28,35 +23,35 @@ function testRemoteEnv(mock, type, command) {
       })
       let err = null
       try {
-        const env = new EnvironmentVar("abc", type, true)
+        const env = new EnvironmentVar('abc', type, true)
         env.syncResolve()
       } catch (e) {
         err = e
       }
       expect(err).is.not.null
-      expect(err?.["message"]).is.not.null
+      expect(err?.['message']).is.not.null
     })
 
-    test("Optional value with null value", async () => {
+    test('Optional value with null value', async () => {
       mock.on(command).resolves({
         Parameter: {
           Value: undefined,
         },
       })
-      const env = new EnvironmentVar("abc", type, true)
+      const env = new EnvironmentVar('abc', type, true)
       const token = await env.resolve()
       expect(token).is.undefined
     })
 
-    test("Optional value with empty response", async () => {
+    test('Optional value with empty response', async () => {
       mock.on(command).resolves({})
-      const env = new EnvironmentVar("abc", type, true)
+      const env = new EnvironmentVar('abc', type, true)
       const token = await env.resolve()
       expect(token).is.undefined
     })
 
-    test("Optional value with valid response", async () => {
-      const value = "abc"
+    test('Optional value with valid response', async () => {
+      const value = 'abc'
       mock.on(command).resolves({
         Parameter: {
           Value: value,
@@ -68,9 +63,9 @@ function testRemoteEnv(mock, type, command) {
       expect(token).to.be.equals(value)
     })
 
-    test("Optional value rejection", async () => {
-      const value = "abc"
-      mock.on(command).rejects(new Error("failed!"))
+    test('Optional value rejection', async () => {
+      const value = 'abc'
+      mock.on(command).rejects(new Error('failed!'))
       const env = new EnvironmentVar(value, type, true)
       const token = await env.resolve()
       expect(token).is.undefined
@@ -83,7 +78,7 @@ function testRemoteEnv(mock, type, command) {
       mock.reset()
     })
 
-    test("Does not accept sync resolve", async () => {
+    test('Does not accept sync resolve', async () => {
       mock.on(command).resolves({
         Parameter: {
           Value: undefined,
@@ -91,16 +86,16 @@ function testRemoteEnv(mock, type, command) {
       })
       let err = null
       try {
-        const env = new EnvironmentVar("abc", type)
+        const env = new EnvironmentVar('abc', type)
         env.syncResolve()
       } catch (e) {
         err = e
       }
       expect(err).is.not.null
-      expect(err?.["message"]).is.not.null
+      expect(err?.['message']).is.not.null
     })
 
-    test("Required fails when null", async () => {
+    test('Required fails when null', async () => {
       mock.on(command).resolves({
         Parameter: {
           Value: undefined,
@@ -108,31 +103,31 @@ function testRemoteEnv(mock, type, command) {
       })
       let err = null
       try {
-        const env = new EnvironmentVar("abc", type)
+        const env = new EnvironmentVar('abc', type)
         await env.resolve()
       } catch (e) {
         err = e
       }
       console.log(err)
       expect(err).is.not.null
-      expect(err?.["message"]).is.not.null
+      expect(err?.['message']).is.not.null
     })
 
-    test("Required fails when empty response", async () => {
+    test('Required fails when empty response', async () => {
       mock.on(command).resolves({})
       let err = null
       try {
-        const env = new EnvironmentVar("abc", type)
+        const env = new EnvironmentVar('abc', type)
         await env.resolve()
       } catch (e) {
         err = e
       }
       expect(err).is.not.null
-      expect(err?.["message"]).is.not.null
+      expect(err?.['message']).is.not.null
     })
 
-    test("Required value with valid response", async () => {
-      const value = "abc"
+    test('Required value with valid response', async () => {
+      const value = 'abc'
       mock.on(command).resolves({
         Parameter: {
           Value: value,
@@ -144,44 +139,40 @@ function testRemoteEnv(mock, type, command) {
       expect(token).to.be.equals(value)
     })
 
-    test("Required value rejection", async () => {
-      mock.on(command).rejects(new Error("failed!"))
+    test('Required value rejection', async () => {
+      mock.on(command).rejects(new Error('failed!'))
       let err = null
       try {
-        const env = new EnvironmentVar("abc", type)
+        const env = new EnvironmentVar('abc', type)
         await env.resolve()
       } catch (e) {
         err = e
       }
       expect(err).is.not.null
-      expect(err?.["message"]).is.not.null
+      expect(err?.['message']).is.not.null
     })
   })
 }
 
 /* Remote envs test */
 testRemoteEnv(SSMMock, EnvironmentType.PlainRemote, GetParameterCommand)
-testRemoteEnv(
-  SecretsManagerMock,
-  EnvironmentType.SecureRemote,
-  GetSecretValueCommand,
-)
-
-describe("Optional Local environment", () => {
-  test("Does accept async resolve", async () => {
-    const env = new EnvironmentVar("PATH123", EnvironmentType.Local, true)
+testRemoteEnv(SecretsManagerMock, EnvironmentType.SecureRemote, GetSecretValueCommand)
+
+describe('Optional Local environment', () => {
+  test('Does accept async resolve', async () => {
+    const env = new EnvironmentVar('PATH123', EnvironmentType.Local, true)
     const v = await env.resolve()
     expect(v).is.undefined
   })
 
-  test("Optional value with null value", async () => {
-    const env = new EnvironmentVar("PATH123", EnvironmentType.Local, true)
+  test('Optional value with null value', async () => {
+    const env = new EnvironmentVar('PATH123', EnvironmentType.Local, true)
     const token = env.syncResolve()
     expect(token).is.undefined
   })
 
-  test("Optional value with valid value", async () => {
-    const key = "PATH"
+  test('Optional value with valid value', async () => {
+    const key = 'PATH'
     const env = new EnvironmentVar(key, EnvironmentType.Local, true)
     const token = env.syncResolve()
     expect(token).is.not.undefined
@@ -189,30 +180,30 @@ describe("Optional Local environment", () => {
   })
 })
 
-describe("Required local environment", () => {
-  test("Does accept async resolve", async () => {
-    const key = "PATH"
+describe('Required local environment', () => {
+  test('Does accept async resolve', async () => {
+    const key = 'PATH'
     const env = new EnvironmentVar(key, EnvironmentType.Local)
     const v = await env.resolve()
     expect(v).is.not.null
     expect(v).to.be.equals(process.env[key])
   })
 
-  test("Required fails when null", async () => {
+  test('Required fails when null', async () => {
     let err = null
     try {
-      const env = new EnvironmentVar("PATH123", EnvironmentType.Local)
+      const env = new EnvironmentVar('PATH123', EnvironmentType.Local)
       env.syncResolve()
     } catch (e) {
       err = e
     }
     console.log(err)
     expect(err).is.not.null
-    expect(err?.["message"]).is.not.null
+    expect(err?.['message']).is.not.null
   })
 
-  test("Required value with valid value", async () => {
-    const key = "PATH"
+  test('Required value with valid value', async () => {
+    const key = 'PATH'
     const env = new EnvironmentVar(key, EnvironmentType.Local)
     const v = env.syncResolve()
     expect(v).is.not.null

package/tests/Crypto/Crypto.test.ts

@@ -1,27 +1,27 @@
-import { DecryptCommand, EncryptCommand, KMSClient } from "@aws-sdk/client-kms"
-import { mockClient } from "aws-sdk-client-mock"
-import { expect } from "chai"
+import { DecryptCommand, EncryptCommand, KMSClient } from '@aws-sdk/client-kms'
+import { mockClient } from 'aws-sdk-client-mock'
+import { expect } from 'chai'
 
-import Crypto from "../../src/Crypto/Crypto"
+import Crypto from '../../src/Crypto/Crypto'
 
 const KMSMock = mockClient(KMSClient)
 
 function fakeEncryption(v) {
   const f = new TextEncoder().encode(v)
-  return Buffer.from(f as any, "utf8").toString("hex")
+  return Buffer.from(f as any, 'utf8').toString('hex')
 }
 function fakeDecryption(v) {
   return new TextEncoder().encode(v)
 }
 
-describe("Encryption", () => {
+describe('Encryption', () => {
   // reset mock
   beforeEach(() => {
     KMSMock.reset()
   })
 
-  const provider = new Crypto("ca-central-1", "abc123")
-  test("Encrypts json object", async () => {
+  const provider = new Crypto('ca-central-1', 'abc123')
+  test('Encrypts json object', async () => {
     const encryptionObj = { userID: 123 }
     KMSMock.on(EncryptCommand).resolves({
       CiphertextBlob: new TextEncoder().encode(JSON.stringify(encryptionObj)),
@@ -31,8 +31,8 @@ describe("Encryption", () => {
     expect(token).to.be.equals(fakeEncryption(JSON.stringify(encryptionObj)))
   })
 
-  test("Encrypts string", async () => {
-    const encryptionText = "Hello encryption!"
+  test('Encrypts string', async () => {
+    const encryptionText = 'Hello encryption!'
     KMSMock.on(EncryptCommand).resolves({
       CiphertextBlob: new TextEncoder().encode(encryptionText),
     })
@@ -41,35 +41,33 @@ describe("Encryption", () => {
     expect(token).to.be.equals(fakeEncryption(encryptionText))
   })
 
-  test("Fails to encrypt a number", async () => {
+  test('Fails to encrypt a number', async () => {
     const encryptionText = 123
-    KMSMock.on(EncryptCommand).rejects(new Error("failed"))
+    KMSMock.on(EncryptCommand).rejects(new Error('failed'))
     const token = await provider.encryptData(encryptionText)
     expect(token).is.null
   })
 })
 
-describe("Decryption", () => {
+describe('Decryption', () => {
   // reset mock
   beforeEach(() => {
     KMSMock.reset()
   })
 
-  const provider = new Crypto("ca-central-1", "abc123")
-  test("Decrypts json object", async () => {
+  const provider = new Crypto('ca-central-1', 'abc123')
+  test('Decrypts json object', async () => {
     const encryptionObj = { userID: 123 }
     KMSMock.on(DecryptCommand).resolves({
       Plaintext: fakeDecryption(JSON.stringify(encryptionObj)),
     })
-    const token = await provider.decryptData(
-      fakeEncryption(JSON.stringify(encryptionObj)),
-    )
+    const token = await provider.decryptData(fakeEncryption(JSON.stringify(encryptionObj)))
     expect(token).is.not.null
     expect(token).to.be.equals(JSON.stringify(encryptionObj))
   })
 
-  test("Decrypts string", async () => {
-    const encryptionText = "abc123"
+  test('Decrypts string', async () => {
+    const encryptionText = 'abc123'
     KMSMock.on(DecryptCommand).resolves({
       Plaintext: fakeDecryption(encryptionText),
     })
@@ -78,9 +76,9 @@ describe("Decryption", () => {
     expect(token).to.be.equals(encryptionText)
   })
 
-  test("Fails to decrypt a number", async () => {
+  test('Fails to decrypt a number', async () => {
     const encryptionText = 123
-    KMSMock.on(DecryptCommand).rejects(new Error("failed"))
+    KMSMock.on(DecryptCommand).rejects(new Error('failed'))
     // @ts-ignore
     const token = await provider.decryptData(encryptionText)
     expect(token).is.null