feat(pkg): add new Otp helper

Author: jlenon7

src/helpers/Otp.ts

@@ -0,0 +1,90 @@
+/**
+ * @athenna/common
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import otpGenerator from 'otp-generator'
+
+export class Otp {
+  /**
+   * Generate an OTP token.
+   */
+  public static generate(prefix?: string) {
+    if (prefix) {
+      return `${prefix}::${otpGenerator.generate(6, {
+        digits: true,
+        specialChars: false,
+        upperCaseAlphabets: true,
+        lowerCaseAlphabets: false
+      })}`
+    }
+
+    return otpGenerator.generate(6, {
+      digits: true,
+      specialChars: false,
+      upperCaseAlphabets: true,
+      lowerCaseAlphabets: false
+    })
+  }
+
+  /**
+   * Return the token without his prefix.
+   */
+  public static getToken(token: string): string {
+    const prefix = Otp.getPrefix(token)
+
+    if (!prefix) {
+      return token
+    }
+
+    return token.split(`${prefix}::`)[1]
+  }
+
+  /**
+   * Return the prefix without his token.
+   */
+  public static getPrefix(token: string): string | null {
+    const prefix = token.split('::')[0]
+
+    /**
+     * Means that the "::" char has not been
+     * found. So there is no prefix in the token.
+     */
+    if (prefix === token) {
+      return null
+    }
+
+    return prefix
+  }
+
+  /**
+   * Inject a prefix in the uuid token.
+   */
+  public static injectPrefix(prefix: string, token: string): string {
+    return `${prefix}::${token}`
+  }
+
+  /**
+   * Change the prefix of an OTP token.
+   */
+  public static changePrefix(newPrefix: string, token: string): string {
+    const otp = this.getToken(token)
+
+    return `${newPrefix}::${otp}`
+  }
+
+  /**
+   * Change the token prefix or generate a new one.
+   */
+  public static changeOrGenerate(prefix: string, token?: string): string {
+    if (token) {
+      return this.changePrefix(prefix, token)
+    }
+
+    return this.generate(prefix)
+  }
+}

src/helpers/String.ts

@@ -8,7 +8,6 @@
  */
 
 import pluralize from 'pluralize'
-import otpGenerator from 'otp-generator'
 import * as changeCase from 'change-case'
 
 import { crc32 } from 'crc'
@@ -55,37 +54,23 @@ export class String {
    * @example
    * ```ts
    * const random = String.random(10) // '1bibr3zxdA'
-   * const random = String.random(10, { otp: true }) // '41NPH'
    * const random = String.random(10, { suffixCRC: true }) // '9-EdWM9OV53876186015'
    * ```
    */
   public static random(
     size: number,
-    options?: { otp?: boolean; suffixCRC?: boolean }
+    options?: { suffixCRC?: boolean }
   ): string {
     options = Options.create(options, {
-      otp: false,
       suffixCRC: false
     })
 
-    let random = ''
-
-    if (options.otp) {
-      random = otpGenerator.generate(size, {
-        digits: true,
-        specialChars: false,
-        upperCaseAlphabets: true,
-        lowerCaseAlphabets: false
-      })
-    } else {
-      const bits = (size + 1) * 6
-      const buffer = randomBytes(Math.ceil(bits / 8))
-
-      random = String.normalizeBase64(buffer.toString('base64'))
-        .replace(/-/g, '')
-        .replace(/_/g, '')
-        .slice(0, size)
-    }
+    const bits = (size + 1) * 6
+    const buffer = randomBytes(Math.ceil(bits / 8))
+    const random = String.normalizeBase64(buffer.toString('base64'))
+      .replace(/-/g, '')
+      .replace(/_/g, '')
+      .slice(0, size)
 
     if (options.suffixCRC) {
       const crc = crc32(random).toString(30)
@@ -103,7 +88,7 @@ export class String {
    * will be removed in the next major version.
    */
   public static generateRandom(size: number): string {
-    return this.random(size, { otp: false, suffixCRC: false })
+    return this.random(size, { suffixCRC: false })
   }
 
   /**

src/index.ts

@@ -27,6 +27,7 @@ export * from '#src/helpers/Json'
 export * from '#src/helpers/Module'
 export * from '#src/helpers/Number'
 export * from '#src/helpers/Options'
+export * from '#src/helpers/Otp'
 export * from '#src/helpers/Parser'
 export * from '#src/helpers/Path'
 export * from '#src/helpers/Route'

tests/unit/helpers/ModuleTest.ts

@@ -67,15 +67,15 @@ export default class ModuleTest {
   public async shouldBeAbleToGetAllModulesFirstExportMatchOrDefaultFromAnyPath({ assert }: Context) {
     const modules = await Module.getAllFrom(Path.src('helpers'))
 
-    assert.lengthOf(modules, 22)
+    assert.lengthOf(modules, 23)
     assert.equal(modules[0].name, 'Clean')
   }
 
   @Test()
   public async shouldBeAbleToGetAllModulesFirstExportMatchOrDefaultFromAnyPathWithAlias({ assert }: Context) {
     const modules = await Module.getAllFromWithAlias(Path.src('helpers'), 'App/Helpers')
 
-    assert.lengthOf(modules, 22)
+    assert.lengthOf(modules, 23)
     assert.equal(modules[0].module.name, 'Clean')
     assert.equal(modules[0].alias, 'App/Helpers/Clean')
   }

tests/unit/helpers/OtpTest.ts

@@ -0,0 +1,56 @@
+/**
+ * @athenna/common
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import otpGenerator from 'otp-generator'
+
+import { Otp } from '#src'
+import { Test, type Context } from '@athenna/test'
+
+export default class OtpTest {
+  private otp = otpGenerator.generate(6, {
+    digits: true,
+    specialChars: false,
+    upperCaseAlphabets: true,
+    lowerCaseAlphabets: false
+  })
+
+  @Test()
+  public shouldGetOnlyTheTokenFromPrefixedOtp({ assert }: Context) {
+    const tokenOtp = Otp.generate('tkn')
+
+    assert.equal(Otp.getToken(tokenOtp), tokenOtp.replace('tkn::', ''))
+  }
+
+  @Test()
+  public shouldGetOnlyThePrefixFromPrefixedOtp({ assert }: Context) {
+    const tokenOtp = Otp.generate('tkn')
+
+    assert.isNull(Otp.getPrefix(this.otp), null)
+    assert.equal(Otp.getPrefix(tokenOtp), 'tkn')
+  }
+
+  @Test()
+  public shouldInjectThePrefixInTheToken({ assert }: Context) {
+    const tokenOtp = Otp.generate()
+    const injectedPrefix = Otp.injectPrefix('tkn', tokenOtp)
+    const tokenPrefixedChange = Otp.changePrefix('any', injectedPrefix)
+
+    assert.equal(injectedPrefix, `tkn::${tokenOtp}`)
+    assert.equal(tokenPrefixedChange, `any::${tokenOtp}`)
+  }
+
+  @Test()
+  public shouldChangeOrGenerateANewToken({ assert }: Context) {
+    const tokenGenerated = Otp.changeOrGenerate('tkn', undefined)
+    const tokenChanged = Otp.changeOrGenerate('tkn', `ooo::${this.otp}`)
+
+    assert.isDefined(tokenGenerated)
+    assert.equal(tokenChanged, `tkn::${this.otp}`)
+  }
+}

tests/unit/helpers/StringTest.ts

@@ -47,7 +47,6 @@ export default class StringTest {
     assert.lengthOf(String.random(10), 10)
     assert.lengthOf(String.random(20), 20)
 
-    assert.lengthOf(String.random(5, { otp: true }), 5)
     assert.lengthOf(String.random(40, { suffixCRC: true }), 40)
 
     assert.lengthOf(String.generateRandom(10), 10)